﻿using UnityEngine;
using System.Collections;

namespace iTManager
{
    public class AudioFrom : IiTweenProperty
    {
        iTweenBase.NamedValueColor IiTweenProperty.NamedColorValue { get; set; }
        float? IiTweenProperty.a { get; set; }
        float? IiTweenProperty.alpha { get; set; }
        float? IiTweenProperty.amount_float { get; set; }
        Vector3? IiTweenProperty.amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        /// <summary>
        /// for which AudioSource to use
        /// </summary>
        public AudioSource audiosource { get; set; }
        string IiTweenProperty.axis { get; set; }
        float? IiTweenProperty.b { get; set; }
        Color? IiTweenProperty.color { get; set; }
        /// <summary>
        /// for the time in seconds the animation will wait before beginning
        /// </summary>
        public float? delay { get; set; }
        /// <summary>
        /// for the shape of the easing curve applied to the animation
        /// </summary>
        public iTweenBase.EaseType easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        float? IiTweenProperty.g { get; set; }
        /// <summary>
        /// setting this to true will allow the animation to continue independent of the current time which is helpful for animating menus after a game has been paused by setting Time.timeScale=0
        /// </summary>
        public bool ignoretimescale { get; set; }
        bool IiTweenProperty.includechildren { get; set; }
        bool IiTweenProperty.islocal { get; set; }
        float? IiTweenProperty.lookahead { get; set; }
        Transform IiTweenProperty.looktarget_Transform { get; set; }
        Vector3? IiTweenProperty.looktarget_Vector3 { get; set; }
        float? IiTweenProperty.looktime { get; set; }
        /// <summary>
        /// for the type of loop to apply once the animation has completed
        /// </summary>
        public iTweenBase.LoopType looptype { get; set; }
        bool IiTweenProperty.movetopath { get; set; }
        /// <summary>
        /// an individual name useful for stopping iTweens by name
        /// </summary>
        public string name { get; set; }
        bool IiTweenProperty.orienttopath { get; set; }
        Transform[] IiTweenProperty.path_Transform { get; set; }
        Vector3[] IiTweenProperty.path_Vector3 { get; set; }
        /// <summary>
        /// for the target pitch
        /// </summary>
        public float? pitch { get; set; }
        Transform IiTweenProperty.position_Transform { get; set; }
        Vector3? IiTweenProperty.position_Vector3 { get; set; }
        float? IiTweenProperty.r { get; set; }
        Transform IiTweenProperty.rotation_Transform { get; set; }
        Vector3? IiTweenProperty.rotation_Vector3 { get; set; }
        Transform IiTweenProperty.scale_Transform { get; set; }
        Vector3? IiTweenProperty.scale_Vector3 { get; set; }
        Space IiTweenProperty.space { get; set; }
        float? IiTweenProperty.speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        /// <summary>
        /// for the target level of volume
        /// </summary>
        public float? volume { get; set; }
        float? IiTweenProperty.x { get; set; }
        float? IiTweenProperty.y { get; set; }
        float? IiTweenProperty.z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class AudioTo : IiTweenProperty
    {
        iTweenBase.NamedValueColor IiTweenProperty.NamedColorValue { get; set; }
        float? IiTweenProperty.a { get; set; }
        float? IiTweenProperty.alpha { get; set; }
        float? IiTweenProperty.amount_float { get; set; }
        Vector3? IiTweenProperty.amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        /// <summary>
        /// for which AudioSource to use
        /// </summary>
        public AudioSource audiosource { get; set; }
        string IiTweenProperty.axis { get; set; }
        float? IiTweenProperty.b { get; set; }
        Color? IiTweenProperty.color { get; set; }
        /// <summary>
        /// for the time in seconds the animation will wait before beginning
        /// </summary>
        public float? delay { get; set; }
        /// <summary>
        /// for the shape of the easing curve applied to the animation
        /// </summary>
        public iTweenBase.EaseType easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        float? IiTweenProperty.g { get; set; }
        /// <summary>
        /// setting this to true will allow the animation to continue independent of the current time which is helpful for animating menus after a game has been paused by setting Time.timeScale=0
        /// </summary>
        public bool ignoretimescale { get; set; }
        bool IiTweenProperty.includechildren { get; set; }
        bool IiTweenProperty.islocal { get; set; }
        float? IiTweenProperty.lookahead { get; set; }
        Transform IiTweenProperty.looktarget_Transform { get; set; }
        Vector3? IiTweenProperty.looktarget_Vector3 { get; set; }
        float? IiTweenProperty.looktime { get; set; }
        /// <summary>
        /// for the type of loop to apply once the animation has completed
        /// </summary>
        public iTweenBase.LoopType looptype { get; set; }
        bool IiTweenProperty.movetopath { get; set; }
        /// <summary>
        /// an individual name useful for stopping iTweens by name
        /// </summary>
        public string name { get; set; }
        bool IiTweenProperty.orienttopath { get; set; }
        Transform[] IiTweenProperty.path_Transform { get; set; }
        Vector3[] IiTweenProperty.path_Vector3 { get; set; }
        /// <summary>
        /// for the target pitch
        /// </summary>
        public float? pitch { get; set; }
        Transform IiTweenProperty.position_Transform { get; set; }
        Vector3? IiTweenProperty.position_Vector3 { get; set; }
        float? IiTweenProperty.r { get; set; }
        Transform IiTweenProperty.rotation_Transform { get; set; }
        Vector3? IiTweenProperty.rotation_Vector3 { get; set; }
        Transform IiTweenProperty.scale_Transform { get; set; }
        Vector3? IiTweenProperty.scale_Vector3 { get; set; }
        Space IiTweenProperty.space { get; set; }
        float? IiTweenProperty.speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        /// <summary>
        /// for the target level of volume
        /// </summary>
        public float? volume { get; set; }
        float? IiTweenProperty.x { get; set; }
        float? IiTweenProperty.y { get; set; }
        float? IiTweenProperty.z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class AudioUpdate : IiTweenProperty
    {
        iTweenBase.NamedValueColor IiTweenProperty.NamedColorValue { get; set; }
        float? IiTweenProperty.a { get; set; }
        float? IiTweenProperty.alpha { get; set; }
        float? IiTweenProperty.amount_float { get; set; }
        Vector3? IiTweenProperty.amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        /// <summary>
        /// for which AudioSource to use
        /// </summary>
        public AudioSource audiosource { get; set; }
        string IiTweenProperty.axis { get; set; }
        float? IiTweenProperty.b { get; set; }
        Color? IiTweenProperty.color { get; set; }
        float? IiTweenProperty.delay { get; set; }
        iTweenBase.EaseType IiTweenProperty.easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        float? IiTweenProperty.g { get; set; }
        bool IiTweenProperty.ignoretimescale { get; set; }
        bool IiTweenProperty.includechildren { get; set; }
        bool IiTweenProperty.islocal { get; set; }
        float? IiTweenProperty.lookahead { get; set; }
        Transform IiTweenProperty.looktarget_Transform { get; set; }
        Vector3? IiTweenProperty.looktarget_Vector3 { get; set; }
        float? IiTweenProperty.looktime { get; set; }
        iTweenBase.LoopType IiTweenProperty.looptype { get; set; }
        bool IiTweenProperty.movetopath { get; set; }
        string IiTweenProperty.name { get; set; }
        bool IiTweenProperty.orienttopath { get; set; }
        Transform[] IiTweenProperty.path_Transform { get; set; }
        Vector3[] IiTweenProperty.path_Vector3 { get; set; }
        /// <summary>
        /// for the target pitch
        /// </summary>
        public float? pitch { get; set; }
        Transform IiTweenProperty.position_Transform { get; set; }
        Vector3? IiTweenProperty.position_Vector3 { get; set; }
        float? IiTweenProperty.r { get; set; }
        Transform IiTweenProperty.rotation_Transform { get; set; }
        Vector3? IiTweenProperty.rotation_Vector3 { get; set; }
        Transform IiTweenProperty.scale_Transform { get; set; }
        Vector3? IiTweenProperty.scale_Vector3 { get; set; }
        Space IiTweenProperty.space { get; set; }
        float? IiTweenProperty.speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        /// <summary>
        /// for the target level of volume
        /// </summary>
        public float? volume { get; set; }
        float? IiTweenProperty.x { get; set; }
        float? IiTweenProperty.y { get; set; }
        float? IiTweenProperty.z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class CameraFadeFrom : IiTweenProperty
    {
        iTweenBase.NamedValueColor IiTweenProperty.NamedColorValue { get; set; }
        float? IiTweenProperty.a { get; set; }
        float? IiTweenProperty.alpha { get; set; }
        /// <summary>
        /// for how transparent the Texture2D that the camera fade uses is
        /// </summary>
        public float? amount_float { get; set; }
        Vector3? IiTweenProperty.amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        AudioSource IiTweenProperty.audiosource { get; set; }
        string IiTweenProperty.axis { get; set; }
        float? IiTweenProperty.b { get; set; }
        Color? IiTweenProperty.color { get; set; }
        /// <summary>
        /// for the time in seconds the animation will wait before beginning
        /// </summary>
        public float? delay { get; set; }
        /// <summary>
        /// for the type of loop to apply once the animation has completed
        /// </summary>
        public iTweenBase.EaseType easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        float? IiTweenProperty.g { get; set; }
        /// <summary>
        /// setting this to true will allow the animation to continue independent of the current time which is helpful for animating menus after a game has been paused by setting Time.timeScale=0
        /// </summary>
        public bool ignoretimescale { get; set; }
        bool IiTweenProperty.includechildren { get; set; }
        bool IiTweenProperty.islocal { get; set; }
        float? IiTweenProperty.lookahead { get; set; }
        Transform IiTweenProperty.looktarget_Transform { get; set; }
        Vector3? IiTweenProperty.looktarget_Vector3 { get; set; }
        float? IiTweenProperty.looktime { get; set; }
        /// <summary>
        /// for the type of loop to apply once the animation has completed
        /// </summary>
        public iTweenBase.LoopType looptype { get; set; }
        bool IiTweenProperty.movetopath { get; set; }
        /// <summary>
        /// an individual name useful for stopping iTweens by name
        /// </summary>
        public string name { get; set; }
        bool IiTweenProperty.orienttopath { get; set; }
        Transform[] IiTweenProperty.path_Transform { get; set; }
        Vector3[] IiTweenProperty.path_Vector3 { get; set; }
        float? IiTweenProperty.pitch { get; set; }
        Transform IiTweenProperty.position_Transform { get; set; }
        Vector3? IiTweenProperty.position_Vector3 { get; set; }
        float? IiTweenProperty.r { get; set; }
        Transform IiTweenProperty.rotation_Transform { get; set; }
        Vector3? IiTweenProperty.rotation_Vector3 { get; set; }
        Transform IiTweenProperty.scale_Transform { get; set; }
        Vector3? IiTweenProperty.scale_Vector3 { get; set; }
        Space IiTweenProperty.space { get; set; }
        float? IiTweenProperty.speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        float? IiTweenProperty.volume { get; set; }
        float? IiTweenProperty.x { get; set; }
        float? IiTweenProperty.y { get; set; }
        float? IiTweenProperty.z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class CameraFadeTo : IiTweenProperty
    {
        iTweenBase.NamedValueColor IiTweenProperty.NamedColorValue { get; set; }
        float? IiTweenProperty.a { get; set; }
        float? IiTweenProperty.alpha { get; set; }
        /// <summary>
        /// for how transparent the Texture2D that the camera fade uses is
        /// </summary>
        public float? amount_float { get; set; }
        Vector3? IiTweenProperty.amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        AudioSource IiTweenProperty.audiosource { get; set; }
        string IiTweenProperty.axis { get; set; }
        float? IiTweenProperty.b { get; set; }
        Color? IiTweenProperty.color { get; set; }
        /// <summary>
        /// for the time in seconds the animation will wait before beginning
        /// </summary>
        public float? delay { get; set; }
        /// <summary>
        /// for the type of loop to apply once the animation has completed
        /// </summary>
        public iTweenBase.EaseType easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        float? IiTweenProperty.g { get; set; }
        /// <summary>
        /// setting this to true will allow the animation to continue independent of the current time which is helpful for animating menus after a game has been paused by setting Time.timeScale=0
        /// </summary>
        public bool ignoretimescale { get; set; }
        bool IiTweenProperty.includechildren { get; set; }
        bool IiTweenProperty.islocal { get; set; }
        float? IiTweenProperty.lookahead { get; set; }
        Transform IiTweenProperty.looktarget_Transform { get; set; }
        Vector3? IiTweenProperty.looktarget_Vector3 { get; set; }
        float? IiTweenProperty.looktime { get; set; }
        /// <summary>
        /// for the type of loop to apply once the animation has completed
        /// </summary>
        public iTweenBase.LoopType looptype { get; set; }
        bool IiTweenProperty.movetopath { get; set; }
        /// <summary>
        /// an individual name useful for stopping iTweens by name
        /// </summary>
        public string name { get; set; }
        bool IiTweenProperty.orienttopath { get; set; }
        Transform[] IiTweenProperty.path_Transform { get; set; }
        Vector3[] IiTweenProperty.path_Vector3 { get; set; }
        float? IiTweenProperty.pitch { get; set; }
        Transform IiTweenProperty.position_Transform { get; set; }
        Vector3? IiTweenProperty.position_Vector3 { get; set; }
        float? IiTweenProperty.r { get; set; }
        Transform IiTweenProperty.rotation_Transform { get; set; }
        Vector3? IiTweenProperty.rotation_Vector3 { get; set; }
        Transform IiTweenProperty.scale_Transform { get; set; }
        Vector3? IiTweenProperty.scale_Vector3 { get; set; }
        Space IiTweenProperty.space { get; set; }
        float? IiTweenProperty.speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        float? IiTweenProperty.volume { get; set; }
        float? IiTweenProperty.x { get; set; }
        float? IiTweenProperty.y { get; set; }
        float? IiTweenProperty.z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class ColorFrom : IiTweenProperty
    {
        /// <summary>
        /// for which color of a shader to use. Uses "_Color" by default.
        /// </summary>
        public iTweenBase.NamedValueColor NamedColorValue { get; set; }
        /// <summary>
        /// for the individual setting of the alpha
        /// </summary>
        public float? a { get; set; }
        float? IiTweenProperty.alpha { get; set; }
        float? IiTweenProperty.amount_float { get; set; }
        Vector3? IiTweenProperty.amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        AudioSource IiTweenProperty.audiosource { get; set; }
        string IiTweenProperty.axis { get; set; }
        /// <summary>
        /// for the individual setting of the color blue
        /// </summary>
        public float? b { get; set; }
        /// <summary>
        /// the color to fade the object to
        /// </summary>
        public Color? color { get; set; }
        /// <summary>
        /// for the time in seconds the animation will wait before beginning
        /// </summary>
        public float? delay { get; set; }
        /// <summary>
        /// for the shape of the easing curve applied to the animation
        /// </summary>
        public iTweenBase.EaseType easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        /// <summary>
        /// for the individual setting of the color green
        /// </summary>
        public float? g { get; set; }
        /// <summary>
        /// setting this to true will allow the animation to continue independent of the current time which is helpful for animating menus after a game has been paused by setting Time.timeScale=0
        /// </summary>
        public bool ignoretimescale { get; set; }
        /// <summary>
        /// for whether or not to include children of this GameObject. True by default
        /// </summary>
        public bool includechildren { get; set; }
        bool IiTweenProperty.islocal { get; set; }
        float? IiTweenProperty.lookahead { get; set; }
        Transform IiTweenProperty.looktarget_Transform { get; set; }
        Vector3? IiTweenProperty.looktarget_Vector3 { get; set; }
        float? IiTweenProperty.looktime { get; set; }
        /// <summary>
        /// for the type of loop to apply once the animation has completed
        /// </summary>
        public iTweenBase.LoopType looptype { get; set; }
        bool IiTweenProperty.movetopath { get; set; }
        /// <summary>
        /// an individual name useful for stopping iTweens by name
        /// </summary>
        public string name { get; set; }
        bool IiTweenProperty.orienttopath { get; set; }
        Transform[] IiTweenProperty.path_Transform { get; set; }
        Vector3[] IiTweenProperty.path_Vector3 { get; set; }
        float? IiTweenProperty.pitch { get; set; }
        Transform IiTweenProperty.position_Transform { get; set; }
        Vector3? IiTweenProperty.position_Vector3 { get; set; }
        /// <summary>
        /// for the individual setting of the color red
        /// </summary>
        public float? r { get; set; }
        Transform IiTweenProperty.rotation_Transform { get; set; }
        Vector3? IiTweenProperty.rotation_Vector3 { get; set; }
        Transform IiTweenProperty.scale_Transform { get; set; }
        Vector3? IiTweenProperty.scale_Vector3 { get; set; }
        Space IiTweenProperty.space { get; set; }
        float? IiTweenProperty.speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        float? IiTweenProperty.volume { get; set; }
        float? IiTweenProperty.x { get; set; }
        float? IiTweenProperty.y { get; set; }
        float? IiTweenProperty.z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class ColorTo : IiTweenProperty
    {
        /// <summary>
        /// for which color of a shader to use. Uses "_Color" by default.
        /// </summary>
        public iTweenBase.NamedValueColor NamedColorValue { get; set; }
        /// <summary>
        /// for the individual setting of the alpha
        /// </summary>
        public float? a { get; set; }
        float? IiTweenProperty.alpha { get; set; }
        float? IiTweenProperty.amount_float { get; set; }
        Vector3? IiTweenProperty.amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        AudioSource IiTweenProperty.audiosource { get; set; }
        string IiTweenProperty.axis { get; set; }
        /// <summary>
        /// for the individual setting of the color blue
        /// </summary>
        public float? b { get; set; }
        /// <summary>
        /// the color to fade the object to
        /// </summary>
        public Color? color { get; set; }
        /// <summary>
        /// for the time in seconds the animation will wait before beginning
        /// </summary>
        public float? delay { get; set; }
        /// <summary>
        /// for the shape of the easing curve applied to the animation
        /// </summary>
        public iTweenBase.EaseType easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        /// <summary>
        /// for the individual setting of the color green
        /// </summary>
        public float? g { get; set; }
        /// <summary>
        /// setting this to true will allow the animation to continue independent of the current time which is helpful for animating menus after a game has been paused by setting Time.timeScale=0
        /// </summary>
        public bool ignoretimescale { get; set; }
        /// <summary>
        /// for whether or not to include children of this GameObject. True by default
        /// </summary>
        public bool includechildren { get; set; }
        bool IiTweenProperty.islocal { get; set; }
        float? IiTweenProperty.lookahead { get; set; }
        Transform IiTweenProperty.looktarget_Transform { get; set; }
        Vector3? IiTweenProperty.looktarget_Vector3 { get; set; }
        float? IiTweenProperty.looktime { get; set; }
        /// <summary>
        /// for the type of loop to apply once the animation has completed
        /// </summary>
        public iTweenBase.LoopType looptype { get; set; }
        bool IiTweenProperty.movetopath { get; set; }
        /// <summary>
        /// an individual name useful for stopping iTweens by name
        /// </summary>
        public string name { get; set; }
        bool IiTweenProperty.orienttopath { get; set; }
        Transform[] IiTweenProperty.path_Transform { get; set; }
        Vector3[] IiTweenProperty.path_Vector3 { get; set; }
        float? IiTweenProperty.pitch { get; set; }
        Transform IiTweenProperty.position_Transform { get; set; }
        Vector3? IiTweenProperty.position_Vector3 { get; set; }
        /// <summary>
        /// for the individual setting of the color red
        /// </summary>
        public float? r { get; set; }
        Transform IiTweenProperty.rotation_Transform { get; set; }
        Vector3? IiTweenProperty.rotation_Vector3 { get; set; }
        Transform IiTweenProperty.scale_Transform { get; set; }
        Vector3? IiTweenProperty.scale_Vector3 { get; set; }
        Space IiTweenProperty.space { get; set; }
        float? IiTweenProperty.speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        float? IiTweenProperty.volume { get; set; }
        float? IiTweenProperty.x { get; set; }
        float? IiTweenProperty.y { get; set; }
        float? IiTweenProperty.z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class ColorUpdate : IiTweenProperty
    {
        /// <summary>
        /// for which color of a shader to use. Uses "_Color" by default.
        /// </summary>
        public iTweenBase.NamedValueColor NamedColorValue { get; set; }
        /// <summary>
        /// for the individual setting of the alpha
        /// </summary>
        public float? a { get; set; }
        float? IiTweenProperty.alpha { get; set; }
        float? IiTweenProperty.amount_float { get; set; }
        Vector3? IiTweenProperty.amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        AudioSource IiTweenProperty.audiosource { get; set; }
        string IiTweenProperty.axis { get; set; }
        /// <summary>
        /// for the individual setting of the color blue
        /// </summary>
        public float? b { get; set; }
        /// <summary>
        /// the color to fade the object to
        /// </summary>
        public Color? color { get; set; }
        float? IiTweenProperty.delay { get; set; }
        iTweenBase.EaseType IiTweenProperty.easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        /// <summary>
        /// for the individual setting of the color green
        /// </summary>
        public float? g { get; set; }
        bool IiTweenProperty.ignoretimescale { get; set; }
        /// <summary>
        /// for whether or not to include children of this GameObject. True by default
        /// </summary>
        public bool includechildren { get; set; }
        bool IiTweenProperty.islocal { get; set; }
        float? IiTweenProperty.lookahead { get; set; }
        Transform IiTweenProperty.looktarget_Transform { get; set; }
        Vector3? IiTweenProperty.looktarget_Vector3 { get; set; }
        float? IiTweenProperty.looktime { get; set; }
        iTweenBase.LoopType IiTweenProperty.looptype { get; set; }
        bool IiTweenProperty.movetopath { get; set; }
        string IiTweenProperty.name { get; set; }
        bool IiTweenProperty.orienttopath { get; set; }
        Transform[] IiTweenProperty.path_Transform { get; set; }
        Vector3[] IiTweenProperty.path_Vector3 { get; set; }
        float? IiTweenProperty.pitch { get; set; }
        Transform IiTweenProperty.position_Transform { get; set; }
        Vector3? IiTweenProperty.position_Vector3 { get; set; }
        /// <summary>
        /// for the individual setting of the color red
        /// </summary>
        public float? r { get; set; }
        Transform IiTweenProperty.rotation_Transform { get; set; }
        Vector3? IiTweenProperty.rotation_Vector3 { get; set; }
        Transform IiTweenProperty.scale_Transform { get; set; }
        Vector3? IiTweenProperty.scale_Vector3 { get; set; }
        Space IiTweenProperty.space { get; set; }
        float? IiTweenProperty.speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        float? IiTweenProperty.volume { get; set; }
        float? IiTweenProperty.x { get; set; }
        float? IiTweenProperty.y { get; set; }
        float? IiTweenProperty.z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class FadeFrom : IiTweenProperty
    {
        /// <summary>
        /// for which color of a shader to use. Uses "_Color" by default.
        /// </summary>
        public iTweenBase.NamedValueColor NamedColorValue { get; set; }
        float? IiTweenProperty.a { get; set; }
        /// <summary>
        /// for the initial alpha value of the animation.
        /// </summary>
        public float? alpha { get; set; }
        /// <summary>
        /// for the initial alpha value of the animation.
        /// </summary>
        public float? amount_float { get; set; }
        Vector3? IiTweenProperty.amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        AudioSource IiTweenProperty.audiosource { get; set; }
        string IiTweenProperty.axis { get; set; }
        float? IiTweenProperty.b { get; set; }
        Color? IiTweenProperty.color { get; set; }
        /// <summary>
        /// for the time in seconds the animation will wait before beginning
        /// </summary>
        public float? delay { get; set; }
        /// <summary>
        /// for the shape of the easing curve applied to the animation
        /// </summary>
        public iTweenBase.EaseType easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        float? IiTweenProperty.g { get; set; }
        /// <summary>
        /// setting this to true will allow the animation to continue independent of the current time which is helpful for animating menus after a game has been paused by setting Time.timeScale=0
        /// </summary>
        public bool ignoretimescale { get; set; }
        /// <summary>
        /// for whether or not to include children of this GameObject. True by default
        /// </summary>
        public bool includechildren { get; set; }
        bool IiTweenProperty.islocal { get; set; }
        float? IiTweenProperty.lookahead { get; set; }
        Transform IiTweenProperty.looktarget_Transform { get; set; }
        Vector3? IiTweenProperty.looktarget_Vector3 { get; set; }
        float? IiTweenProperty.looktime { get; set; }
        /// <summary>
        /// for the type of loop to apply once the animation has completed
        /// </summary>
        public iTweenBase.LoopType looptype { get; set; }
        bool IiTweenProperty.movetopath { get; set; }
        /// <summary>
        /// an individual name useful for stopping iTweens by name
        /// </summary>
        public string name { get; set; }
        bool IiTweenProperty.orienttopath { get; set; }
        Transform[] IiTweenProperty.path_Transform { get; set; }
        Vector3[] IiTweenProperty.path_Vector3 { get; set; }
        float? IiTweenProperty.pitch { get; set; }
        Transform IiTweenProperty.position_Transform { get; set; }
        Vector3? IiTweenProperty.position_Vector3 { get; set; }
        float? IiTweenProperty.r { get; set; }
        Transform IiTweenProperty.rotation_Transform { get; set; }
        Vector3? IiTweenProperty.rotation_Vector3 { get; set; }
        Transform IiTweenProperty.scale_Transform { get; set; }
        Vector3? IiTweenProperty.scale_Vector3 { get; set; }
        Space IiTweenProperty.space { get; set; }
        float? IiTweenProperty.speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        float? IiTweenProperty.volume { get; set; }
        float? IiTweenProperty.x { get; set; }
        float? IiTweenProperty.y { get; set; }
        float? IiTweenProperty.z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class FadeTo : IiTweenProperty
    {
        /// <summary>
        /// for which color of a shader to use. Uses "_Color" by default.
        /// </summary>
        public iTweenBase.NamedValueColor NamedColorValue { get; set; }
        float? IiTweenProperty.a { get; set; }
        /// <summary>
        /// for the initial alpha value of the animation.
        /// </summary>
        public float? alpha { get; set; }
        /// <summary>
        /// for the initial alpha value of the animation.
        /// </summary>
        public float? amount_float { get; set; }
        Vector3? IiTweenProperty.amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        AudioSource IiTweenProperty.audiosource { get; set; }
        string IiTweenProperty.axis { get; set; }
        float? IiTweenProperty.b { get; set; }
        Color? IiTweenProperty.color { get; set; }
        /// <summary>
        /// for the time in seconds the animation will wait before beginning
        /// </summary>
        public float? delay { get; set; }
        /// <summary>
        /// for the shape of the easing curve applied to the animation
        /// </summary>
        public iTweenBase.EaseType easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        float? IiTweenProperty.g { get; set; }
        /// <summary>
        /// setting this to true will allow the animation to continue independent of the current time which is helpful for animating menus after a game has been paused by setting Time.timeScale=0
        /// </summary>
        public bool ignoretimescale { get; set; }
        /// <summary>
        /// for whether or not to include children of this GameObject. True by default
        /// </summary>
        public bool includechildren { get; set; }
        bool IiTweenProperty.islocal { get; set; }
        float? IiTweenProperty.lookahead { get; set; }
        Transform IiTweenProperty.looktarget_Transform { get; set; }
        Vector3? IiTweenProperty.looktarget_Vector3 { get; set; }
        float? IiTweenProperty.looktime { get; set; }
        /// <summary>
        /// for the type of loop to apply once the animation has completed
        /// </summary>
        public iTweenBase.LoopType looptype { get; set; }
        bool IiTweenProperty.movetopath { get; set; }
        /// <summary>
        /// an individual name useful for stopping iTweens by name
        /// </summary>
        public string name { get; set; }
        bool IiTweenProperty.orienttopath { get; set; }
        Transform[] IiTweenProperty.path_Transform { get; set; }
        Vector3[] IiTweenProperty.path_Vector3 { get; set; }
        float? IiTweenProperty.pitch { get; set; }
        Transform IiTweenProperty.position_Transform { get; set; }
        Vector3? IiTweenProperty.position_Vector3 { get; set; }
        float? IiTweenProperty.r { get; set; }
        Transform IiTweenProperty.rotation_Transform { get; set; }
        Vector3? IiTweenProperty.rotation_Vector3 { get; set; }
        Transform IiTweenProperty.scale_Transform { get; set; }
        Vector3? IiTweenProperty.scale_Vector3 { get; set; }
        Space IiTweenProperty.space { get; set; }
        float? IiTweenProperty.speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        float? IiTweenProperty.volume { get; set; }
        float? IiTweenProperty.x { get; set; }
        float? IiTweenProperty.y { get; set; }
        float? IiTweenProperty.z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class FadeUpdate : IiTweenProperty
    {
        iTweenBase.NamedValueColor IiTweenProperty.NamedColorValue { get; set; }
        float? IiTweenProperty.a { get; set; }
        /// <summary>
        /// for the individual setting of the alpha
        /// </summary>
        public float? alpha { get; set; }
        float? IiTweenProperty.amount_float { get; set; }
        Vector3? IiTweenProperty.amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        AudioSource IiTweenProperty.audiosource { get; set; }
        string IiTweenProperty.axis { get; set; }
        float? IiTweenProperty.b { get; set; }
        Color? IiTweenProperty.color { get; set; }
        float? IiTweenProperty.delay { get; set; }
        iTweenBase.EaseType IiTweenProperty.easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        float? IiTweenProperty.g { get; set; }
        bool IiTweenProperty.ignoretimescale { get; set; }
        /// <summary>
        /// for whether or not to include children of this GameObject. True by default
        /// </summary>
        public bool includechildren { get; set; }
        bool IiTweenProperty.islocal { get; set; }
        float? IiTweenProperty.lookahead { get; set; }
        Transform IiTweenProperty.looktarget_Transform { get; set; }
        Vector3? IiTweenProperty.looktarget_Vector3 { get; set; }
        float? IiTweenProperty.looktime { get; set; }
        iTweenBase.LoopType IiTweenProperty.looptype { get; set; }
        bool IiTweenProperty.movetopath { get; set; }
        string IiTweenProperty.name { get; set; }
        bool IiTweenProperty.orienttopath { get; set; }
        Transform[] IiTweenProperty.path_Transform { get; set; }
        Vector3[] IiTweenProperty.path_Vector3 { get; set; }
        float? IiTweenProperty.pitch { get; set; }
        Transform IiTweenProperty.position_Transform { get; set; }
        Vector3? IiTweenProperty.position_Vector3 { get; set; }
        float? IiTweenProperty.r { get; set; }
        Transform IiTweenProperty.rotation_Transform { get; set; }
        Vector3? IiTweenProperty.rotation_Vector3 { get; set; }
        Transform IiTweenProperty.scale_Transform { get; set; }
        Vector3? IiTweenProperty.scale_Vector3 { get; set; }
        Space IiTweenProperty.space { get; set; }
        float? IiTweenProperty.speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        float? IiTweenProperty.volume { get; set; }
        float? IiTweenProperty.x { get; set; }
        float? IiTweenProperty.y { get; set; }
        float? IiTweenProperty.z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class LookFrom : IiTweenProperty
    {
        iTweenBase.NamedValueColor IiTweenProperty.NamedColorValue { get; set; }
        float? IiTweenProperty.a { get; set; }
        float? IiTweenProperty.alpha { get; set; }
        float? IiTweenProperty.amount_float { get; set; }
        Vector3? IiTweenProperty.amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        AudioSource IiTweenProperty.audiosource { get; set; }
        /// <summary>
        /// Restricts rotation to the supplied axis only.
        /// </summary>
        public string axis { get; set; }
        float? IiTweenProperty.b { get; set; }
        Color? IiTweenProperty.color { get; set; }
        /// <summary>
        /// for the time in seconds the animation will wait before beginning
        /// </summary>
        public float? delay { get; set; }
        /// <summary>
        /// for the shape of the easing curve applied to the animation
        /// </summary>
        public iTweenBase.EaseType easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        float? IiTweenProperty.g { get; set; }
        /// <summary>
        /// setting this to true will allow the animation to continue independent of the current time which is helpful for animating menus after a game has been paused by setting Time.timeScale=0
        /// </summary>
        public bool ignoretimescale { get; set; }
        bool IiTweenProperty.includechildren { get; set; }
        bool IiTweenProperty.islocal { get; set; }
        float? IiTweenProperty.lookahead { get; set; }
        /// <summary>
        /// for a target the GameObject will look at.
        /// </summary>
        public Transform looktarget_Transform { get; set; }
        /// <summary>
        /// for a target the GameObject will look at.
        /// </summary>
        public Vector3? looktarget_Vector3 { get; set; }
        float? IiTweenProperty.looktime { get; set; }
        /// <summary>
        /// for the type of loop to apply once the animation has completed
        /// </summary>
        public iTweenBase.LoopType looptype { get; set; }
        bool IiTweenProperty.movetopath { get; set; }
        /// <summary>
        /// an individual name useful for stopping iTweens by name
        /// </summary>
        public string name { get; set; }
        bool IiTweenProperty.orienttopath { get; set; }
        Transform[] IiTweenProperty.path_Transform { get; set; }
        Vector3[] IiTweenProperty.path_Vector3 { get; set; }
        float? IiTweenProperty.pitch { get; set; }
        Transform IiTweenProperty.position_Transform { get; set; }
        Vector3? IiTweenProperty.position_Vector3 { get; set; }
        float? IiTweenProperty.r { get; set; }
        Transform IiTweenProperty.rotation_Transform { get; set; }
        Vector3? IiTweenProperty.rotation_Vector3 { get; set; }
        Transform IiTweenProperty.scale_Transform { get; set; }
        Vector3? IiTweenProperty.scale_Vector3 { get; set; }
        Space IiTweenProperty.space { get; set; }
        /// <summary>
        /// can be used instead of time to allow animation based on speed
        /// </summary>
        public float? speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        float? IiTweenProperty.volume { get; set; }
        float? IiTweenProperty.x { get; set; }
        float? IiTweenProperty.y { get; set; }
        float? IiTweenProperty.z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class LookTo : IiTweenProperty
    {
        iTweenBase.NamedValueColor IiTweenProperty.NamedColorValue { get; set; }
        float? IiTweenProperty.a { get; set; }
        float? IiTweenProperty.alpha { get; set; }
        float? IiTweenProperty.amount_float { get; set; }
        Vector3? IiTweenProperty.amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        AudioSource IiTweenProperty.audiosource { get; set; }
        /// <summary>
        /// Restricts rotation to the supplied axis only.
        /// </summary>
        public string axis { get; set; }
        float? IiTweenProperty.b { get; set; }
        Color? IiTweenProperty.color { get; set; }
        /// <summary>
        /// for the time in seconds the animation will wait before beginning
        /// </summary>
        public float? delay { get; set; }
        /// <summary>
        /// for the shape of the easing curve applied to the animation
        /// </summary>
        public iTweenBase.EaseType easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        float? IiTweenProperty.g { get; set; }
        /// <summary>
        /// setting this to true will allow the animation to continue independent of the current time which is helpful for animating menus after a game has been paused by setting Time.timeScale=0
        /// </summary>
        public bool ignoretimescale { get; set; }
        bool IiTweenProperty.includechildren { get; set; }
        bool IiTweenProperty.islocal { get; set; }
        float? IiTweenProperty.lookahead { get; set; }
        /// <summary>
        /// for a target the GameObject will look at.
        /// </summary>
        public Transform looktarget_Transform { get; set; }
        /// <summary>
        /// for a target the GameObject will look at.
        /// </summary>
        public Vector3? looktarget_Vector3 { get; set; }
        float? IiTweenProperty.looktime { get; set; }
        /// <summary>
        /// for the type of loop to apply once the animation has completed
        /// </summary>
        public iTweenBase.LoopType looptype { get; set; }
        bool IiTweenProperty.movetopath { get; set; }
        /// <summary>
        /// an individual name useful for stopping iTweens by name
        /// </summary>
        public string name { get; set; }
        bool IiTweenProperty.orienttopath { get; set; }
        Transform[] IiTweenProperty.path_Transform { get; set; }
        Vector3[] IiTweenProperty.path_Vector3 { get; set; }
        float? IiTweenProperty.pitch { get; set; }
        Transform IiTweenProperty.position_Transform { get; set; }
        Vector3? IiTweenProperty.position_Vector3 { get; set; }
        float? IiTweenProperty.r { get; set; }
        Transform IiTweenProperty.rotation_Transform { get; set; }
        Vector3? IiTweenProperty.rotation_Vector3 { get; set; }
        Transform IiTweenProperty.scale_Transform { get; set; }
        Vector3? IiTweenProperty.scale_Vector3 { get; set; }
        Space IiTweenProperty.space { get; set; }
        /// <summary>
        /// can be used instead of time to allow animation based on speed
        /// </summary>
        public float? speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        float? IiTweenProperty.volume { get; set; }
        float? IiTweenProperty.x { get; set; }
        float? IiTweenProperty.y { get; set; }
        float? IiTweenProperty.z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class LookUpdate : IiTweenProperty
    {
        iTweenBase.NamedValueColor IiTweenProperty.NamedColorValue { get; set; }
        float? IiTweenProperty.a { get; set; }
        float? IiTweenProperty.alpha { get; set; }
        float? IiTweenProperty.amount_float { get; set; }
        Vector3? IiTweenProperty.amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        AudioSource IiTweenProperty.audiosource { get; set; }
        /// <summary>
        /// Restricts rotation to the supplied axis only.
        /// </summary>
        public string axis { get; set; }
        float? IiTweenProperty.b { get; set; }
        Color? IiTweenProperty.color { get; set; }
        float? IiTweenProperty.delay { get; set; }
        iTweenBase.EaseType IiTweenProperty.easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        float? IiTweenProperty.g { get; set; }
        bool IiTweenProperty.ignoretimescale { get; set; }
        bool IiTweenProperty.includechildren { get; set; }
        bool IiTweenProperty.islocal { get; set; }
        float? IiTweenProperty.lookahead { get; set; }
        /// <summary>
        /// for a target the GameObject will look at.
        /// </summary>
        public Transform looktarget_Transform { get; set; }
        /// <summary>
        /// for a target the GameObject will look at.
        /// </summary>
        public Vector3? looktarget_Vector3 { get; set; }
        float? IiTweenProperty.looktime { get; set; }
        iTweenBase.LoopType IiTweenProperty.looptype { get; set; }
        bool IiTweenProperty.movetopath { get; set; }
        string IiTweenProperty.name { get; set; }
        bool IiTweenProperty.orienttopath { get; set; }
        Transform[] IiTweenProperty.path_Transform { get; set; }
        Vector3[] IiTweenProperty.path_Vector3 { get; set; }
        float? IiTweenProperty.pitch { get; set; }
        Transform IiTweenProperty.position_Transform { get; set; }
        Vector3? IiTweenProperty.position_Vector3 { get; set; }
        float? IiTweenProperty.r { get; set; }
        Transform IiTweenProperty.rotation_Transform { get; set; }
        Vector3? IiTweenProperty.rotation_Vector3 { get; set; }
        Transform IiTweenProperty.scale_Transform { get; set; }
        Vector3? IiTweenProperty.scale_Vector3 { get; set; }
        Space IiTweenProperty.space { get; set; }
        float? IiTweenProperty.speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        float? IiTweenProperty.volume { get; set; }
        float? IiTweenProperty.x { get; set; }
        float? IiTweenProperty.y { get; set; }
        float? IiTweenProperty.z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class MoveAdd : IiTweenProperty
    {
        iTweenBase.NamedValueColor IiTweenProperty.NamedColorValue { get; set; }
        float? IiTweenProperty.a { get; set; }
        float? IiTweenProperty.alpha { get; set; }
        float? IiTweenProperty.amount_float { get; set; }
        /// <summary>
        /// for a point in space the GameObject will animate to.
        /// </summary>
        public Vector3? amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        AudioSource IiTweenProperty.audiosource { get; set; }
        /// <summary>
        /// restricts rotation to the supplied axis only
        /// </summary>
        public string axis { get; set; }
        float? IiTweenProperty.b { get; set; }
        Color? IiTweenProperty.color { get; set; }
        /// <summary>
        /// for the time in seconds the animation will wait before beginning
        /// </summary>
        public float? delay { get; set; }
        /// <summary>
        /// for the shape of the easing curve applied to the animation
        /// </summary>
        public iTweenBase.EaseType easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        float? IiTweenProperty.g { get; set; }
        /// <summary>
        /// setting this to true will allow the animation to continue independent of the current time which is helpful for animating menus after a game has been paused by setting Time.timeScale=0
        /// </summary>
        public bool ignoretimescale { get; set; }
        bool IiTweenProperty.includechildren { get; set; }
        bool IiTweenProperty.islocal { get; set; }
        float? IiTweenProperty.lookahead { get; set; }
        /// <summary>
        /// for a target the GameObject will look at
        /// </summary>
        public Transform looktarget_Transform { get; set; }
        /// <summary>
        /// for a target the GameObject will look at
        /// </summary>
        public Vector3? looktarget_Vector3 { get; set; }
        /// <summary>
        /// for the time in seconds the object will take to look at either the "looktarget" or "orienttopath"
        /// </summary>
        public float? looktime { get; set; }
        /// <summary>
        /// for the type of loop to apply once the animation has completed
        /// </summary>
        public iTweenBase.LoopType looptype { get; set; }
        bool IiTweenProperty.movetopath { get; set; }
        /// <summary>
        /// an individual name useful for stopping iTweens by name
        /// </summary>
        public string name { get; set; }
        /// <summary>
        /// for whether or not the GameObject will orient to its direction of travel.  False by default
        /// </summary>
        public bool orienttopath { get; set; }
        Transform[] IiTweenProperty.path_Transform { get; set; }
        Vector3[] IiTweenProperty.path_Vector3 { get; set; }
        float? IiTweenProperty.pitch { get; set; }
        Transform IiTweenProperty.position_Transform { get; set; }
        Vector3? IiTweenProperty.position_Vector3 { get; set; }
        float? IiTweenProperty.r { get; set; }
        Transform IiTweenProperty.rotation_Transform { get; set; }
        Vector3? IiTweenProperty.rotation_Vector3 { get; set; }
        Transform IiTweenProperty.scale_Transform { get; set; }
        Vector3? IiTweenProperty.scale_Vector3 { get; set; }
        /// <summary>
        /// for applying the transformation in either the world coordinate or local cordinate system. Defaults to local space
        /// </summary>
        public Space space { get; set; }
        /// <summary>
        /// can be used instead of time to allow animation based on speed
        /// </summary>
        public float? speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        float? IiTweenProperty.volume { get; set; }
        /// <summary>
        /// for the individual setting of the x axis
        /// </summary>
        public float? x { get; set; }
        /// <summary>
        /// for the individual setting of the y axis
        /// </summary>
        public float? y { get; set; }
        /// <summary>
        /// for the individual setting of the z axis
        /// </summary>
        public float? z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class MoveBy : IiTweenProperty
    {
        iTweenBase.NamedValueColor IiTweenProperty.NamedColorValue { get; set; }
        float? IiTweenProperty.a { get; set; }
        float? IiTweenProperty.alpha { get; set; }
        float? IiTweenProperty.amount_float { get; set; }
        /// <summary>
        /// for a point in space the GameObject will animate to.
        /// </summary>
        public Vector3? amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        AudioSource IiTweenProperty.audiosource { get; set; }
        /// <summary>
        /// restricts rotation to the supplied axis only
        /// </summary>
        public string axis { get; set; }
        float? IiTweenProperty.b { get; set; }
        Color? IiTweenProperty.color { get; set; }
        /// <summary>
        /// for the time in seconds the animation will wait before beginning
        /// </summary>
        public float? delay { get; set; }
        /// <summary>
        /// for the shape of the easing curve applied to the animation
        /// </summary>
        public iTweenBase.EaseType easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        float? IiTweenProperty.g { get; set; }
        /// <summary>
        /// setting this to true will allow the animation to continue independent of the current time which is helpful for animating menus after a game has been paused by setting Time.timeScale=0
        /// </summary>
        public bool ignoretimescale { get; set; }
        bool IiTweenProperty.includechildren { get; set; }
        bool IiTweenProperty.islocal { get; set; }
        float? IiTweenProperty.lookahead { get; set; }
        /// <summary>
        /// for a target the GameObject will look at
        /// </summary>
        public Transform looktarget_Transform { get; set; }
        /// <summary>
        /// for a target the GameObject will look at
        /// </summary>
        public Vector3? looktarget_Vector3 { get; set; }
        /// <summary>
        /// for the time in seconds the object will take to look at either the "looktarget" or "orienttopath"
        /// </summary>
        public float? looktime { get; set; }
        /// <summary>
        /// for the type of loop to apply once the animation has completed
        /// </summary>
        public iTweenBase.LoopType looptype { get; set; }
        bool IiTweenProperty.movetopath { get; set; }
        /// <summary>
        /// an individual name useful for stopping iTweens by name
        /// </summary>
        public string name { get; set; }
        /// <summary>
        /// for whether or not the GameObject will orient to its direction of travel.  False by default
        /// </summary>
        public bool orienttopath { get; set; }
        Transform[] IiTweenProperty.path_Transform { get; set; }
        Vector3[] IiTweenProperty.path_Vector3 { get; set; }
        float? IiTweenProperty.pitch { get; set; }
        Transform IiTweenProperty.position_Transform { get; set; }
        Vector3? IiTweenProperty.position_Vector3 { get; set; }
        float? IiTweenProperty.r { get; set; }
        Transform IiTweenProperty.rotation_Transform { get; set; }
        Vector3? IiTweenProperty.rotation_Vector3 { get; set; }
        Transform IiTweenProperty.scale_Transform { get; set; }
        Vector3? IiTweenProperty.scale_Vector3 { get; set; }
        /// <summary>
        /// for applying the transformation in either the world coordinate or local cordinate system. Defaults to local space
        /// </summary>
        public Space space { get; set; }
        /// <summary>
        /// can be used instead of time to allow animation based on speed
        /// </summary>
        public float? speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        float? IiTweenProperty.volume { get; set; }
        /// <summary>
        /// for the individual setting of the x axis
        /// </summary>
        public float? x { get; set; }
        /// <summary>
        /// for the individual setting of the y axis
        /// </summary>
        public float? y { get; set; }
        /// <summary>
        /// for the individual setting of the z axis
        /// </summary>
        public float? z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class MoveFrom : IiTweenProperty
    {
        iTweenBase.NamedValueColor IiTweenProperty.NamedColorValue { get; set; }
        float? IiTweenProperty.a { get; set; }
        float? IiTweenProperty.alpha { get; set; }
        float? IiTweenProperty.amount_float { get; set; }
        Vector3? IiTweenProperty.amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        AudioSource IiTweenProperty.audiosource { get; set; }
        /// <summary>
        /// restricts rotation to the supplied axis only
        /// </summary>
        public string axis { get; set; }
        float? IiTweenProperty.b { get; set; }
        Color? IiTweenProperty.color { get; set; }
        /// <summary>
        /// for the time in seconds the animation will wait before beginning
        /// </summary>
        public float? delay { get; set; }
        /// <summary>
        /// for the shape of the easing curve applied to the animation
        /// </summary>
        public iTweenBase.EaseType easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        float? IiTweenProperty.g { get; set; }
        /// <summary>
        /// setting this to true will allow the animation to continue independent of the current time which is helpful for animating menus after a game has been paused by setting Time.timeScale=0
        /// </summary>
        public bool ignoretimescale { get; set; }
        bool IiTweenProperty.includechildren { get; set; }
        /// <summary>
        /// for whether to animate in world space or relative to the parent. False be default.
        /// </summary>
        public bool islocal { get; set; }
        /// <summary>
        /// for how much of a percentage (from 0 to 1) to look ahead on a path to influence how strict "orienttopath" is and how much the object will anticipate each curve 
        /// </summary>
        public float? lookahead { get; set; }
        /// <summary>
        /// for a target the GameObject will look at
        /// </summary>
        public Transform looktarget_Transform { get; set; }
        /// <summary>
        /// for a target the GameObject will look at
        /// </summary>
        public Vector3? looktarget_Vector3 { get; set; }
        /// <summary>
        /// for the time in seconds the object will take to look at either the "looktarget" or "orienttopath"
        /// </summary>
        public float? looktime { get; set; }
        /// <summary>
        /// for the type of loop to apply once the animation has completed
        /// </summary>
        public iTweenBase.LoopType looptype { get; set; }
        /// <summary>
        /// for whether to automatically generate a curve from the GameObject's current position to the beginning of the path. True by default.
        /// </summary>
        public bool movetopath { get; set; }
        /// <summary>
        /// an individual name useful for stopping iTweens by name
        /// </summary>
        public string name { get; set; }
        /// <summary>
        /// for whether or not the GameObject will orient to its direction of travel.  False by default
        /// </summary>
        public bool orienttopath { get; set; }
        /// <summary>
        /// for a list of points to draw a Catmull-Rom through for a curved animation path
        /// </summary>
        public Transform[] path_Transform { get; set; }
        /// <summary>
        /// for a list of points to draw a Catmull-Rom through for a curved animation path
        /// </summary>
        public Vector3[] path_Vector3 { get; set; }
        float? IiTweenProperty.pitch { get; set; }
        /// <summary>
        /// for a point in space the GameObject will animate to.
        /// </summary>
        public Transform position_Transform { get; set; }
        /// <summary>
        /// for a point in space the GameObject will animate to.
        /// </summary>
        public Vector3? position_Vector3 { get; set; }
        float? IiTweenProperty.r { get; set; }
        Transform IiTweenProperty.rotation_Transform { get; set; }
        Vector3? IiTweenProperty.rotation_Vector3 { get; set; }
        Transform IiTweenProperty.scale_Transform { get; set; }
        Vector3? IiTweenProperty.scale_Vector3 { get; set; }
        Space IiTweenProperty.space { get; set; }
        /// <summary>
        /// can be used instead of time to allow animation based on speed
        /// </summary>
        public float? speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        float? IiTweenProperty.volume { get; set; }
        /// <summary>
        /// for the individual setting of the x axis
        /// </summary>
        public float? x { get; set; }
        /// <summary>
        /// for the individual setting of the y axis
        /// </summary>
        public float? y { get; set; }
        /// <summary>
        /// for the individual setting of the z axis
        /// </summary>
        public float? z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class MoveTo : IiTweenProperty
    {
        iTweenBase.NamedValueColor IiTweenProperty.NamedColorValue { get; set; }
        float? IiTweenProperty.a { get; set; }
        float? IiTweenProperty.alpha { get; set; }
        float? IiTweenProperty.amount_float { get; set; }
        Vector3? IiTweenProperty.amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        AudioSource IiTweenProperty.audiosource { get; set; }
        /// <summary>
        /// restricts rotation to the supplied axis only
        /// </summary>
        public string axis { get; set; }
        float? IiTweenProperty.b { get; set; }
        Color? IiTweenProperty.color { get; set; }
        /// <summary>
        /// for the time in seconds the animation will wait before beginning
        /// </summary>
        public float? delay { get; set; }
        /// <summary>
        /// for the shape of the easing curve applied to the animation
        /// </summary>
        public iTweenBase.EaseType easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        float? IiTweenProperty.g { get; set; }
        /// <summary>
        /// setting this to true will allow the animation to continue independent of the current time which is helpful for animating menus after a game has been paused by setting Time.timeScale=0
        /// </summary>
        public bool ignoretimescale { get; set; }
        bool IiTweenProperty.includechildren { get; set; }
        /// <summary>
        /// for whether to animate in world space or relative to the parent. False be default.
        /// </summary>
        public bool islocal { get; set; }
        /// <summary>
        /// for how much of a percentage (from 0 to 1) to look ahead on a path to influence how strict "orienttopath" is and how much the object will anticipate each curve 
        /// </summary>
        public float? lookahead { get; set; }
        /// <summary>
        /// for a target the GameObject will look at
        /// </summary>
        public Transform looktarget_Transform { get; set; }
        /// <summary>
        /// for a target the GameObject will look at
        /// </summary>
        public Vector3? looktarget_Vector3 { get; set; }
        /// <summary>
        /// for the time in seconds the object will take to look at either the "looktarget" or "orienttopath"
        /// </summary>
        public float? looktime { get; set; }
        /// <summary>
        /// for the type of loop to apply once the animation has completed
        /// </summary>
        public iTweenBase.LoopType looptype { get; set; }
        /// <summary>
        /// for whether to automatically generate a curve from the GameObject's current position to the beginning of the path. True by default.
        /// </summary>
        public bool movetopath { get; set; }
        /// <summary>
        /// an individual name useful for stopping iTweens by name
        /// </summary>
        public string name { get; set; }
        /// <summary>
        /// for whether or not the GameObject will orient to its direction of travel.  False by default
        /// </summary>
        public bool orienttopath { get; set; }
        /// <summary>
        /// for a list of points to draw a Catmull-Rom through for a curved animation path
        /// </summary>
        public Transform[] path_Transform { get; set; }
        /// <summary>
        /// for a list of points to draw a Catmull-Rom through for a curved animation path
        /// </summary>
        public Vector3[] path_Vector3 { get; set; }
        float? IiTweenProperty.pitch { get; set; }
        /// <summary>
        /// for a point in space the GameObject will animate to.
        /// </summary>
        public Transform position_Transform { get; set; }
        /// <summary>
        /// for a point in space the GameObject will animate to.
        /// </summary>
        public Vector3? position_Vector3 { get; set; }
        float? IiTweenProperty.r { get; set; }
        Transform IiTweenProperty.rotation_Transform { get; set; }
        Vector3? IiTweenProperty.rotation_Vector3 { get; set; }
        Transform IiTweenProperty.scale_Transform { get; set; }
        Vector3? IiTweenProperty.scale_Vector3 { get; set; }
        Space IiTweenProperty.space { get; set; }
        /// <summary>
        /// can be used instead of time to allow animation based on speed
        /// </summary>
        public float? speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        float? IiTweenProperty.volume { get; set; }
        /// <summary>
        /// for the individual setting of the x axis
        /// </summary>
        public float? x { get; set; }
        /// <summary>
        /// for the individual setting of the y axis
        /// </summary>
        public float? y { get; set; }
        /// <summary>
        /// for the individual setting of the z axis
        /// </summary>
        public float? z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class MoveUpdate : IiTweenProperty
    {
        iTweenBase.NamedValueColor IiTweenProperty.NamedColorValue { get; set; }
        float? IiTweenProperty.a { get; set; }
        float? IiTweenProperty.alpha { get; set; }
        float? IiTweenProperty.amount_float { get; set; }
        Vector3? IiTweenProperty.amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        AudioSource IiTweenProperty.audiosource { get; set; }
        /// <summary>
        /// restricts rotation to the supplied axis only
        /// </summary>
        public string axis { get; set; }
        float? IiTweenProperty.b { get; set; }
        Color? IiTweenProperty.color { get; set; }
        float? IiTweenProperty.delay { get; set; }
        iTweenBase.EaseType IiTweenProperty.easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        float? IiTweenProperty.g { get; set; }
        bool IiTweenProperty.ignoretimescale { get; set; }
        bool IiTweenProperty.includechildren { get; set; }
        /// <summary>
        /// for whether to animate in world space or relative to the parent. False be default.
        /// </summary>
        public bool islocal { get; set; }
        float? IiTweenProperty.lookahead { get; set; }
        /// <summary>
        /// for a target the GameObject will look at
        /// </summary>
        public Transform looktarget_Transform { get; set; }
        /// <summary>
        /// for a target the GameObject will look at
        /// </summary>
        public Vector3? looktarget_Vector3 { get; set; }
        /// <summary>
        /// for the time in seconds the object will take to look at either the "looktarget" or "orienttopath"
        /// </summary>
        public float? looktime { get; set; }
        iTweenBase.LoopType IiTweenProperty.looptype { get; set; }
        bool IiTweenProperty.movetopath { get; set; }
        string IiTweenProperty.name { get; set; }
        /// <summary>
        /// for whether or not the GameObject will orient to its direction of travel.  False by default
        /// </summary>
        public bool orienttopath { get; set; }
        Transform[] IiTweenProperty.path_Transform { get; set; }
        Vector3[] IiTweenProperty.path_Vector3 { get; set; }
        float? IiTweenProperty.pitch { get; set; }
        /// <summary>
        /// for a point in space the GameObject will animate to.
        /// </summary>
        public Transform position_Transform { get; set; }
        /// <summary>
        /// for a point in space the GameObject will animate to.
        /// </summary>
        public Vector3? position_Vector3 { get; set; }
        float? IiTweenProperty.r { get; set; }
        Transform IiTweenProperty.rotation_Transform { get; set; }
        Vector3? IiTweenProperty.rotation_Vector3 { get; set; }
        Transform IiTweenProperty.scale_Transform { get; set; }
        Vector3? IiTweenProperty.scale_Vector3 { get; set; }
        Space IiTweenProperty.space { get; set; }
        float? IiTweenProperty.speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        float? IiTweenProperty.volume { get; set; }
        /// <summary>
        /// for the individual setting of the x axis
        /// </summary>
        public float? x { get; set; }
        /// <summary>
        /// for the individual setting of the y axis
        /// </summary>
        public float? y { get; set; }
        /// <summary>
        /// for the individual setting of the z axis
        /// </summary>
        public float? z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class PunchPosition : IiTweenProperty
    {
        iTweenBase.NamedValueColor IiTweenProperty.NamedColorValue { get; set; }
        float? IiTweenProperty.a { get; set; }
        float? IiTweenProperty.alpha { get; set; }
        float? IiTweenProperty.amount_float { get; set; }
        /// <summary>
        /// for a point in space the GameObject will animate to.
        /// </summary>
        public Vector3? amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        AudioSource IiTweenProperty.audiosource { get; set; }
        /// <summary>
        /// restricts rotation to the supplied axis only
        /// </summary>
        public string axis { get; set; }
        float? IiTweenProperty.b { get; set; }
        Color? IiTweenProperty.color { get; set; }
        /// <summary>
        /// for the time in seconds the animation will wait before beginning
        /// </summary>
        public float? delay { get; set; }
        iTweenBase.EaseType IiTweenProperty.easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        float? IiTweenProperty.g { get; set; }
        /// <summary>
        /// setting this to true will allow the animation to continue independent of the current time which is helpful for animating menus after a game has been paused by setting Time.timeScale=0
        /// </summary>
        public bool ignoretimescale { get; set; }
        bool IiTweenProperty.includechildren { get; set; }
        bool IiTweenProperty.islocal { get; set; }
        float? IiTweenProperty.lookahead { get; set; }
        /// <summary>
        /// for a target the GameObject will look at
        /// </summary>
        public Transform looktarget_Transform { get; set; }
        /// <summary>
        /// for a target the GameObject will look at
        /// </summary>
        public Vector3? looktarget_Vector3 { get; set; }
        /// <summary>
        /// for the time in seconds the object will take to look at either the "looktarget" or "orienttopath"
        /// </summary>
        public float? looktime { get; set; }
        /// <summary>
        /// for the type of loop to apply once the animation has completed (only "loop" is allowed with punches)
        /// </summary>
        public iTweenBase.LoopType looptype { get; set; }
        bool IiTweenProperty.movetopath { get; set; }
        /// <summary>
        /// an individual name useful for stopping iTweens by name
        /// </summary>
        public string name { get; set; }
        bool IiTweenProperty.orienttopath { get; set; }
        Transform[] IiTweenProperty.path_Transform { get; set; }
        Vector3[] IiTweenProperty.path_Vector3 { get; set; }
        float? IiTweenProperty.pitch { get; set; }
        Transform IiTweenProperty.position_Transform { get; set; }
        Vector3? IiTweenProperty.position_Vector3 { get; set; }
        float? IiTweenProperty.r { get; set; }
        Transform IiTweenProperty.rotation_Transform { get; set; }
        Vector3? IiTweenProperty.rotation_Vector3 { get; set; }
        Transform IiTweenProperty.scale_Transform { get; set; }
        Vector3? IiTweenProperty.scale_Vector3 { get; set; }
        /// <summary>
        /// for applying the transformation in either the world coordinate or local coordinate system. Defaults to local space.
        /// </summary>
        public Space space { get; set; }
        float? IiTweenProperty.speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        float? IiTweenProperty.volume { get; set; }
        /// <summary>
        /// for the individual setting of the x magnitude
        /// </summary>
        public float? x { get; set; }
        /// <summary>
        /// for the individual setting of the y magnitude
        /// </summary>
        public float? y { get; set; }
        /// <summary>
        /// for the individual setting of the z magnitude
        /// </summary>
        public float? z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class PunchRotation : IiTweenProperty
    {
        iTweenBase.NamedValueColor IiTweenProperty.NamedColorValue { get; set; }
        float? IiTweenProperty.a { get; set; }
        float? IiTweenProperty.alpha { get; set; }
        float? IiTweenProperty.amount_float { get; set; }
        /// <summary>
        /// for a point in space the GameObject will animate to.
        /// </summary>
        public Vector3? amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        AudioSource IiTweenProperty.audiosource { get; set; }
        string IiTweenProperty.axis { get; set; }
        float? IiTweenProperty.b { get; set; }
        Color? IiTweenProperty.color { get; set; }
        /// <summary>
        /// for the time in seconds the animation will wait before beginning
        /// </summary>
        public float? delay { get; set; }
        iTweenBase.EaseType IiTweenProperty.easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        float? IiTweenProperty.g { get; set; }
        /// <summary>
        /// setting this to true will allow the animation to continue independent of the current time which is helpful for animating menus after a game has been paused by setting Time.timeScale=0
        /// </summary>
        public bool ignoretimescale { get; set; }
        bool IiTweenProperty.includechildren { get; set; }
        bool IiTweenProperty.islocal { get; set; }
        float? IiTweenProperty.lookahead { get; set; }
        Transform IiTweenProperty.looktarget_Transform { get; set; }
        Vector3? IiTweenProperty.looktarget_Vector3 { get; set; }
        float? IiTweenProperty.looktime { get; set; }
        /// <summary>
        /// for the type of loop to apply once the animation has completed (only "loop" is allowed with punches)
        /// </summary>
        public iTweenBase.LoopType looptype { get; set; }
        bool IiTweenProperty.movetopath { get; set; }
        /// <summary>
        /// an individual name useful for stopping iTweens by name
        /// </summary>
        public string name { get; set; }
        bool IiTweenProperty.orienttopath { get; set; }
        Transform[] IiTweenProperty.path_Transform { get; set; }
        Vector3[] IiTweenProperty.path_Vector3 { get; set; }
        float? IiTweenProperty.pitch { get; set; }
        Transform IiTweenProperty.position_Transform { get; set; }
        Vector3? IiTweenProperty.position_Vector3 { get; set; }
        float? IiTweenProperty.r { get; set; }
        Transform IiTweenProperty.rotation_Transform { get; set; }
        Vector3? IiTweenProperty.rotation_Vector3 { get; set; }
        Transform IiTweenProperty.scale_Transform { get; set; }
        Vector3? IiTweenProperty.scale_Vector3 { get; set; }
        /// <summary>
        /// for applying the transformation in either the world coordinate or local cordinate system. Defaults to local space.
        /// </summary>
        public Space space { get; set; }
        float? IiTweenProperty.speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        float? IiTweenProperty.volume { get; set; }
        /// <summary>
        /// for the individual setting of the x magnitude
        /// </summary>
        public float? x { get; set; }
        /// <summary>
        /// for the individual setting of the y magnitude
        /// </summary>
        public float? y { get; set; }
        /// <summary>
        /// for the individual setting of the z magnitude
        /// </summary>
        public float? z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class PunchScale : IiTweenProperty
    {
        iTweenBase.NamedValueColor IiTweenProperty.NamedColorValue { get; set; }
        float? IiTweenProperty.a { get; set; }
        float? IiTweenProperty.alpha { get; set; }
        float? IiTweenProperty.amount_float { get; set; }
        /// <summary>
        /// for a point in space the GameObject will animate to.
        /// </summary>
        public Vector3? amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        AudioSource IiTweenProperty.audiosource { get; set; }
        string IiTweenProperty.axis { get; set; }
        float? IiTweenProperty.b { get; set; }
        Color? IiTweenProperty.color { get; set; }
        /// <summary>
        /// for the time in seconds the animation will wait before beginning
        /// </summary>
        public float? delay { get; set; }
        iTweenBase.EaseType IiTweenProperty.easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        float? IiTweenProperty.g { get; set; }
        /// <summary>
        /// setting this to true will allow the animation to continue independent of the current time which is helpful for animating menus after a game has been paused by setting Time.timeScale=0
        /// </summary>
        public bool ignoretimescale { get; set; }
        bool IiTweenProperty.includechildren { get; set; }
        bool IiTweenProperty.islocal { get; set; }
        float? IiTweenProperty.lookahead { get; set; }
        Transform IiTweenProperty.looktarget_Transform { get; set; }
        Vector3? IiTweenProperty.looktarget_Vector3 { get; set; }
        float? IiTweenProperty.looktime { get; set; }
        /// <summary>
        /// for the type of loop to apply once the animation has completed (only "loop" is allowed with punches)
        /// </summary>
        public iTweenBase.LoopType looptype { get; set; }
        bool IiTweenProperty.movetopath { get; set; }
        /// <summary>
        /// an individual name useful for stopping iTweens by name
        /// </summary>
        public string name { get; set; }
        bool IiTweenProperty.orienttopath { get; set; }
        Transform[] IiTweenProperty.path_Transform { get; set; }
        Vector3[] IiTweenProperty.path_Vector3 { get; set; }
        float? IiTweenProperty.pitch { get; set; }
        Transform IiTweenProperty.position_Transform { get; set; }
        Vector3? IiTweenProperty.position_Vector3 { get; set; }
        float? IiTweenProperty.r { get; set; }
        Transform IiTweenProperty.rotation_Transform { get; set; }
        Vector3? IiTweenProperty.rotation_Vector3 { get; set; }
        Transform IiTweenProperty.scale_Transform { get; set; }
        Vector3? IiTweenProperty.scale_Vector3 { get; set; }
        Space IiTweenProperty.space { get; set; }
        float? IiTweenProperty.speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        float? IiTweenProperty.volume { get; set; }
        /// <summary>
        /// for the individual setting of the x magnitude
        /// </summary>
        public float? x { get; set; }
        /// <summary>
        /// for the individual setting of the y magnitude
        /// </summary>
        public float? y { get; set; }
        /// <summary>
        /// for the individual setting of the z magnitude
        /// </summary>
        public float? z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class RotateAdd : IiTweenProperty
    {
        iTweenBase.NamedValueColor IiTweenProperty.NamedColorValue { get; set; }
        float? IiTweenProperty.a { get; set; }
        float? IiTweenProperty.alpha { get; set; }
        float? IiTweenProperty.amount_float { get; set; }
        /// <summary>
        /// for the amount of Euler angles in degrees to add to the current rotation of the GameObject.
        /// </summary>
        public Vector3? amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        AudioSource IiTweenProperty.audiosource { get; set; }
        string IiTweenProperty.axis { get; set; }
        float? IiTweenProperty.b { get; set; }
        Color? IiTweenProperty.color { get; set; }
        /// <summary>
        /// for the time in seconds the animation will wait before beginning
        /// </summary>
        public float? delay { get; set; }
        /// <summary>
        /// for the shape of the easing curve applied to the animation
        /// </summary>
        public iTweenBase.EaseType easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        float? IiTweenProperty.g { get; set; }
        /// <summary>
        /// setting this to true will allow the animation to continue independent of the current time which is helpful for animating menus after a game has been paused by setting Time.timeScale=0
        /// </summary>
        public bool ignoretimescale { get; set; }
        bool IiTweenProperty.includechildren { get; set; }
        bool IiTweenProperty.islocal { get; set; }
        float? IiTweenProperty.lookahead { get; set; }
        Transform IiTweenProperty.looktarget_Transform { get; set; }
        Vector3? IiTweenProperty.looktarget_Vector3 { get; set; }
        float? IiTweenProperty.looktime { get; set; }
        /// <summary>
        /// for the type of loop to apply once the animation has completed
        /// </summary>
        public iTweenBase.LoopType looptype { get; set; }
        bool IiTweenProperty.movetopath { get; set; }
        /// <summary>
        /// an individual name useful for stopping iTweens by name
        /// </summary>
        public string name { get; set; }
        bool IiTweenProperty.orienttopath { get; set; }
        Transform[] IiTweenProperty.path_Transform { get; set; }
        Vector3[] IiTweenProperty.path_Vector3 { get; set; }
        float? IiTweenProperty.pitch { get; set; }
        Transform IiTweenProperty.position_Transform { get; set; }
        Vector3? IiTweenProperty.position_Vector3 { get; set; }
        float? IiTweenProperty.r { get; set; }
        Transform IiTweenProperty.rotation_Transform { get; set; }
        Vector3? IiTweenProperty.rotation_Vector3 { get; set; }
        Transform IiTweenProperty.scale_Transform { get; set; }
        Vector3? IiTweenProperty.scale_Vector3 { get; set; }
        /// <summary>
        /// for applying the transformation in either the world coordinate or local cordinate system. Defaults to local space.
        /// </summary>
        public Space space { get; set; }
        /// <summary>
        /// can be used instead of time to allow animation based on speed
        /// </summary>
        public float? speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        float? IiTweenProperty.volume { get; set; }
        /// <summary>
        /// for the individual setting of the x axis
        /// </summary>
        public float? x { get; set; }
        /// <summary>
        /// for the individual setting of the y axis
        /// </summary>
        public float? y { get; set; }
        /// <summary>
        /// for the individual setting of the z axis
        /// </summary>
        public float? z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class RotateBy : IiTweenProperty
    {
        iTweenBase.NamedValueColor IiTweenProperty.NamedColorValue { get; set; }
        float? IiTweenProperty.a { get; set; }
        float? IiTweenProperty.alpha { get; set; }
        float? IiTweenProperty.amount_float { get; set; }
        /// <summary>
        /// for the amount to be multiplied by 360 to rotate the GameObject.
        /// </summary>
        public Vector3? amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        AudioSource IiTweenProperty.audiosource { get; set; }
        string IiTweenProperty.axis { get; set; }
        float? IiTweenProperty.b { get; set; }
        Color? IiTweenProperty.color { get; set; }
        /// <summary>
        /// for the time in seconds the animation will wait before beginning
        /// </summary>
        public float? delay { get; set; }
        /// <summary>
        /// for the shape of the easing curve applied to the animation
        /// </summary>
        public iTweenBase.EaseType easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        float? IiTweenProperty.g { get; set; }
        /// <summary>
        /// setting this to true will allow the animation to continue independent of the current time which is helpful for animating menus after a game has been paused by setting Time.timeScale=0
        /// </summary>
        public bool ignoretimescale { get; set; }
        bool IiTweenProperty.includechildren { get; set; }
        bool IiTweenProperty.islocal { get; set; }
        float? IiTweenProperty.lookahead { get; set; }
        Transform IiTweenProperty.looktarget_Transform { get; set; }
        Vector3? IiTweenProperty.looktarget_Vector3 { get; set; }
        float? IiTweenProperty.looktime { get; set; }
        /// <summary>
        /// for the type of loop to apply once the animation has completed
        /// </summary>
        public iTweenBase.LoopType looptype { get; set; }
        bool IiTweenProperty.movetopath { get; set; }
        /// <summary>
        /// an individual name useful for stopping iTweens by name
        /// </summary>
        public string name { get; set; }
        bool IiTweenProperty.orienttopath { get; set; }
        Transform[] IiTweenProperty.path_Transform { get; set; }
        Vector3[] IiTweenProperty.path_Vector3 { get; set; }
        float? IiTweenProperty.pitch { get; set; }
        Transform IiTweenProperty.position_Transform { get; set; }
        Vector3? IiTweenProperty.position_Vector3 { get; set; }
        float? IiTweenProperty.r { get; set; }
        Transform IiTweenProperty.rotation_Transform { get; set; }
        Vector3? IiTweenProperty.rotation_Vector3 { get; set; }
        Transform IiTweenProperty.scale_Transform { get; set; }
        Vector3? IiTweenProperty.scale_Vector3 { get; set; }
        /// <summary>
        /// for applying the transformation in either the world coordinate or local cordinate system. Defaults to local space.
        /// </summary>
        public Space space { get; set; }
        /// <summary>
        /// can be used instead of time to allow animation based on speed
        /// </summary>
        public float? speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        float? IiTweenProperty.volume { get; set; }
        /// <summary>
        /// for the individual setting of the x axis
        /// </summary>
        public float? x { get; set; }
        /// <summary>
        /// for the individual setting of the y axis
        /// </summary>
        public float? y { get; set; }
        /// <summary>
        /// for the individual setting of the z axis
        /// </summary>
        public float? z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class RotateFrom : IiTweenProperty
    {
        iTweenBase.NamedValueColor IiTweenProperty.NamedColorValue { get; set; }
        float? IiTweenProperty.a { get; set; }
        float? IiTweenProperty.alpha { get; set; }
        float? IiTweenProperty.amount_float { get; set; }
        Vector3? IiTweenProperty.amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        AudioSource IiTweenProperty.audiosource { get; set; }
        string IiTweenProperty.axis { get; set; }
        float? IiTweenProperty.b { get; set; }
        Color? IiTweenProperty.color { get; set; }
        /// <summary>
        /// for the time in seconds the animation will wait before beginning
        /// </summary>
        public float? delay { get; set; }
        /// <summary>
        /// for the shape of the easing curve applied to the animation
        /// </summary>
        public iTweenBase.EaseType easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        float? IiTweenProperty.g { get; set; }
        /// <summary>
        /// setting this to true will allow the animation to continue independent of the current time which is helpful for animating menus after a game has been paused by setting Time.timeScale=0
        /// </summary>
        public bool ignoretimescale { get; set; }
        bool IiTweenProperty.includechildren { get; set; }
        /// <summary>
        /// for whether to animate in world space or relative to the parent. False be default.
        /// </summary>
        public bool islocal { get; set; }
        float? IiTweenProperty.lookahead { get; set; }
        Transform IiTweenProperty.looktarget_Transform { get; set; }
        Vector3? IiTweenProperty.looktarget_Vector3 { get; set; }
        float? IiTweenProperty.looktime { get; set; }
        /// <summary>
        /// for the type of loop to apply once the animation has completed
        /// </summary>
        public iTweenBase.LoopType looptype { get; set; }
        bool IiTweenProperty.movetopath { get; set; }
        /// <summary>
        /// an individual name useful for stopping iTweens by name
        /// </summary>
        public string name { get; set; }
        bool IiTweenProperty.orienttopath { get; set; }
        Transform[] IiTweenProperty.path_Transform { get; set; }
        Vector3[] IiTweenProperty.path_Vector3 { get; set; }
        float? IiTweenProperty.pitch { get; set; }
        Transform IiTweenProperty.position_Transform { get; set; }
        Vector3? IiTweenProperty.position_Vector3 { get; set; }
        float? IiTweenProperty.r { get; set; }
        /// <summary>
        /// for the target Euler angles in degrees to rotate to.
        /// </summary>
        public Transform rotation_Transform { get; set; }
        /// <summary>
        /// for the target Euler angles in degrees to rotate to.
        /// </summary>
        public Vector3? rotation_Vector3 { get; set; }
        Transform IiTweenProperty.scale_Transform { get; set; }
        Vector3? IiTweenProperty.scale_Vector3 { get; set; }
        Space IiTweenProperty.space { get; set; }
        /// <summary>
        /// can be used instead of time to allow animation based on speed
        /// </summary>
        public float? speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        float? IiTweenProperty.volume { get; set; }
        /// <summary>
        /// for the individual setting of the x axis
        /// </summary>
        public float? x { get; set; }
        /// <summary>
        /// for the individual setting of the y axis
        /// </summary>
        public float? y { get; set; }
        /// <summary>
        /// for the individual setting of the z axis
        /// </summary>
        public float? z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class RotateTo : IiTweenProperty
    {
        iTweenBase.NamedValueColor IiTweenProperty.NamedColorValue { get; set; }
        float? IiTweenProperty.a { get; set; }
        float? IiTweenProperty.alpha { get; set; }
        float? IiTweenProperty.amount_float { get; set; }
        Vector3? IiTweenProperty.amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        AudioSource IiTweenProperty.audiosource { get; set; }
        string IiTweenProperty.axis { get; set; }
        float? IiTweenProperty.b { get; set; }
        Color? IiTweenProperty.color { get; set; }
        /// <summary>
        /// for the time in seconds the animation will wait before beginning
        /// </summary>
        public float? delay { get; set; }
        /// <summary>
        /// for the shape of the easing curve applied to the animation
        /// </summary>
        public iTweenBase.EaseType easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        float? IiTweenProperty.g { get; set; }
        /// <summary>
        /// setting this to true will allow the animation to continue independent of the current time which is helpful for animating menus after a game has been paused by setting Time.timeScale=0
        /// </summary>
        public bool ignoretimescale { get; set; }
        bool IiTweenProperty.includechildren { get; set; }
        /// <summary>
        /// for whether to animate in world space or relative to the parent. False be default.
        /// </summary>
        public bool islocal { get; set; }
        float? IiTweenProperty.lookahead { get; set; }
        Transform IiTweenProperty.looktarget_Transform { get; set; }
        Vector3? IiTweenProperty.looktarget_Vector3 { get; set; }
        float? IiTweenProperty.looktime { get; set; }
        /// <summary>
        /// for the type of loop to apply once the animation has completed
        /// </summary>
        public iTweenBase.LoopType looptype { get; set; }
        bool IiTweenProperty.movetopath { get; set; }
        /// <summary>
        /// an individual name useful for stopping iTweens by name
        /// </summary>
        public string name { get; set; }
        bool IiTweenProperty.orienttopath { get; set; }
        Transform[] IiTweenProperty.path_Transform { get; set; }
        Vector3[] IiTweenProperty.path_Vector3 { get; set; }
        float? IiTweenProperty.pitch { get; set; }
        Transform IiTweenProperty.position_Transform { get; set; }
        Vector3? IiTweenProperty.position_Vector3 { get; set; }
        float? IiTweenProperty.r { get; set; }
        /// <summary>
        /// for the target Euler angles in degrees to rotate to.
        /// </summary>
        public Transform rotation_Transform { get; set; }
        /// <summary>
        /// for the target Euler angles in degrees to rotate to.
        /// </summary>
        public Vector3? rotation_Vector3 { get; set; }
        Transform IiTweenProperty.scale_Transform { get; set; }
        Vector3? IiTweenProperty.scale_Vector3 { get; set; }
        Space IiTweenProperty.space { get; set; }
        /// <summary>
        /// can be used instead of time to allow animation based on speed
        /// </summary>
        public float? speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        float? IiTweenProperty.volume { get; set; }
        /// <summary>
        /// for the individual setting of the x axis
        /// </summary>
        public float? x { get; set; }
        /// <summary>
        /// for the individual setting of the y axis
        /// </summary>
        public float? y { get; set; }
        /// <summary>
        /// for the individual setting of the z axis
        /// </summary>
        public float? z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class RotateUpdate : IiTweenProperty
    {
        iTweenBase.NamedValueColor IiTweenProperty.NamedColorValue { get; set; }
        float? IiTweenProperty.a { get; set; }
        float? IiTweenProperty.alpha { get; set; }
        float? IiTweenProperty.amount_float { get; set; }
        Vector3? IiTweenProperty.amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        AudioSource IiTweenProperty.audiosource { get; set; }
        string IiTweenProperty.axis { get; set; }
        float? IiTweenProperty.b { get; set; }
        Color? IiTweenProperty.color { get; set; }
        float? IiTweenProperty.delay { get; set; }
        iTweenBase.EaseType IiTweenProperty.easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        float? IiTweenProperty.g { get; set; }
        bool IiTweenProperty.ignoretimescale { get; set; }
        bool IiTweenProperty.includechildren { get; set; }
        /// <summary>
        /// for whether to animate in world space or relative to the parent. False be default.
        /// </summary>
        public bool islocal { get; set; }
        float? IiTweenProperty.lookahead { get; set; }
        Transform IiTweenProperty.looktarget_Transform { get; set; }
        Vector3? IiTweenProperty.looktarget_Vector3 { get; set; }
        float? IiTweenProperty.looktime { get; set; }
        iTweenBase.LoopType IiTweenProperty.looptype { get; set; }
        bool IiTweenProperty.movetopath { get; set; }
        string IiTweenProperty.name { get; set; }
        bool IiTweenProperty.orienttopath { get; set; }
        Transform[] IiTweenProperty.path_Transform { get; set; }
        Vector3[] IiTweenProperty.path_Vector3 { get; set; }
        float? IiTweenProperty.pitch { get; set; }
        Transform IiTweenProperty.position_Transform { get; set; }
        Vector3? IiTweenProperty.position_Vector3 { get; set; }
        float? IiTweenProperty.r { get; set; }
        /// <summary>
        /// for the target Euler angles in degrees to rotate to.
        /// </summary>
        public Transform rotation_Transform { get; set; }
        /// <summary>
        /// for the target Euler angles in degrees to rotate to.
        /// </summary>
        public Vector3? rotation_Vector3 { get; set; }
        Transform IiTweenProperty.scale_Transform { get; set; }
        Vector3? IiTweenProperty.scale_Vector3 { get; set; }
        Space IiTweenProperty.space { get; set; }
        float? IiTweenProperty.speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        float? IiTweenProperty.volume { get; set; }
        /// <summary>
        /// for the individual setting of the x axis
        /// </summary>
        public float? x { get; set; }
        /// <summary>
        /// for the individual setting of the y axis
        /// </summary>
        public float? y { get; set; }
        /// <summary>
        /// for the individual setting of the z axis
        /// </summary>
        public float? z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class ScaleAdd : IiTweenProperty
    {
        iTweenBase.NamedValueColor IiTweenProperty.NamedColorValue { get; set; }
        float? IiTweenProperty.a { get; set; }
        float? IiTweenProperty.alpha { get; set; }
        float? IiTweenProperty.amount_float { get; set; }
        public Vector3? amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        AudioSource IiTweenProperty.audiosource { get; set; }
        string IiTweenProperty.axis { get; set; }
        float? IiTweenProperty.b { get; set; }
        Color? IiTweenProperty.color { get; set; }
        /// <summary>
        /// for the time in seconds the animation will wait before beginning
        /// </summary>
        public float? delay { get; set; }
        /// <summary>
        /// for the shape of the easing curve applied to the animation
        /// </summary>
        public iTweenBase.EaseType easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        float? IiTweenProperty.g { get; set; }
        /// <summary>
        /// setting this to true will allow the animation to continue independent of the current time which is helpful for animating menus after a game has been paused by setting Time.timeScale=0
        /// </summary>
        public bool ignoretimescale { get; set; }
        bool IiTweenProperty.includechildren { get; set; }
        bool IiTweenProperty.islocal { get; set; }
        float? IiTweenProperty.lookahead { get; set; }
        Transform IiTweenProperty.looktarget_Transform { get; set; }
        Vector3? IiTweenProperty.looktarget_Vector3 { get; set; }
        float? IiTweenProperty.looktime { get; set; }
        /// <summary>
        /// for the type of loop to apply once the animation has completed
        /// </summary>
        public iTweenBase.LoopType looptype { get; set; }
        bool IiTweenProperty.movetopath { get; set; }
        /// <summary>
        /// an individual name useful for stopping iTweens by name
        /// </summary>
        public string name { get; set; }
        bool IiTweenProperty.orienttopath { get; set; }
        Transform[] IiTweenProperty.path_Transform { get; set; }
        Vector3[] IiTweenProperty.path_Vector3 { get; set; }
        float? IiTweenProperty.pitch { get; set; }
        Transform IiTweenProperty.position_Transform { get; set; }
        Vector3? IiTweenProperty.position_Vector3 { get; set; }
        float? IiTweenProperty.r { get; set; }
        Transform IiTweenProperty.rotation_Transform { get; set; }
        Vector3? IiTweenProperty.rotation_Vector3 { get; set; }
        Transform IiTweenProperty.scale_Transform { get; set; }
        Vector3? IiTweenProperty.scale_Vector3 { get; set; }
        Space IiTweenProperty.space { get; set; }
        /// <summary>
        /// can be used instead of time to allow animation based on speed
        /// </summary>
        public float? speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        float? IiTweenProperty.volume { get; set; }
        /// <summary>
        /// for the individual setting of the x axis
        /// </summary>
        public float? x { get; set; }
        /// <summary>
        /// for the individual setting of the y axis
        /// </summary>
        public float? y { get; set; }
        /// <summary>
        /// for the individual setting of the z axis
        /// </summary>
        public float? z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class ScaleBy : IiTweenProperty
    {
        iTweenBase.NamedValueColor IiTweenProperty.NamedColorValue { get; set; }
        float? IiTweenProperty.a { get; set; }
        float? IiTweenProperty.alpha { get; set; }
        float? IiTweenProperty.amount_float { get; set; }
        /// <summary>
        /// for the amount to be added to the GameObject's current scale.
        /// </summary>
        public Vector3? amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        AudioSource IiTweenProperty.audiosource { get; set; }
        string IiTweenProperty.axis { get; set; }
        float? IiTweenProperty.b { get; set; }
        Color? IiTweenProperty.color { get; set; }
        /// <summary>
        /// for the time in seconds the animation will wait before beginning
        /// </summary>
        public float? delay { get; set; }
        /// <summary>
        /// for the shape of the easing curve applied to the animation
        /// </summary>
        public iTweenBase.EaseType easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        float? IiTweenProperty.g { get; set; }
        /// <summary>
        /// setting this to true will allow the animation to continue independent of the current time which is helpful for animating menus after a game has been paused by setting Time.timeScale=0
        /// </summary>
        public bool ignoretimescale { get; set; }
        bool IiTweenProperty.includechildren { get; set; }
        bool IiTweenProperty.islocal { get; set; }
        float? IiTweenProperty.lookahead { get; set; }
        Transform IiTweenProperty.looktarget_Transform { get; set; }
        Vector3? IiTweenProperty.looktarget_Vector3 { get; set; }
        float? IiTweenProperty.looktime { get; set; }
        /// <summary>
        /// for the type of loop to apply once the animation has completed
        /// </summary>
        public iTweenBase.LoopType looptype { get; set; }
        bool IiTweenProperty.movetopath { get; set; }
        /// <summary>
        /// an individual name useful for stopping iTweens by name
        /// </summary>
        public string name { get; set; }
        bool IiTweenProperty.orienttopath { get; set; }
        Transform[] IiTweenProperty.path_Transform { get; set; }
        Vector3[] IiTweenProperty.path_Vector3 { get; set; }
        float? IiTweenProperty.pitch { get; set; }
        Transform IiTweenProperty.position_Transform { get; set; }
        Vector3? IiTweenProperty.position_Vector3 { get; set; }
        float? IiTweenProperty.r { get; set; }
        Transform IiTweenProperty.rotation_Transform { get; set; }
        Vector3? IiTweenProperty.rotation_Vector3 { get; set; }
        Transform IiTweenProperty.scale_Transform { get; set; }
        Vector3? IiTweenProperty.scale_Vector3 { get; set; }
        Space IiTweenProperty.space { get; set; }
        /// <summary>
        /// can be used instead of time to allow animation based on speed
        /// </summary>
        public float? speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        float? IiTweenProperty.volume { get; set; }
        /// <summary>
        /// for the individual setting of the x axis
        /// </summary>
        public float? x { get; set; }
        /// <summary>
        /// for the individual setting of the y axis
        /// </summary>
        public float? y { get; set; }
        /// <summary>
        /// for the individual setting of the z axis
        /// </summary>
        public float? z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class ScaleFrom : IiTweenProperty
    {
        iTweenBase.NamedValueColor IiTweenProperty.NamedColorValue { get; set; }
        float? IiTweenProperty.a { get; set; }
        float? IiTweenProperty.alpha { get; set; }
        float? IiTweenProperty.amount_float { get; set; }
        Vector3? IiTweenProperty.amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        AudioSource IiTweenProperty.audiosource { get; set; }
        string IiTweenProperty.axis { get; set; }
        float? IiTweenProperty.b { get; set; }
        Color? IiTweenProperty.color { get; set; }
        /// <summary>
        /// for the time in seconds the animation will wait before beginning
        /// </summary>
        public float? delay { get; set; }
        /// <summary>
        /// for the shape of the easing curve applied to the animation
        /// </summary>
        public iTweenBase.EaseType easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        float? IiTweenProperty.g { get; set; }
        /// <summary>
        /// setting this to true will allow the animation to continue independent of the current time which is helpful for animating menus after a game has been paused by setting Time.timeScale=0
        /// </summary>
        public bool ignoretimescale { get; set; }
        bool IiTweenProperty.includechildren { get; set; }
        bool IiTweenProperty.islocal { get; set; }
        float? IiTweenProperty.lookahead { get; set; }
        Transform IiTweenProperty.looktarget_Transform { get; set; }
        Vector3? IiTweenProperty.looktarget_Vector3 { get; set; }
        float? IiTweenProperty.looktime { get; set; }
        /// <summary>
        /// for the type of loop to apply once the animation has completed
        /// </summary>
        public iTweenBase.LoopType looptype { get; set; }
        bool IiTweenProperty.movetopath { get; set; }
        /// <summary>
        /// an individual name useful for stopping iTweens by name
        /// </summary>
        public string name { get; set; }
        bool IiTweenProperty.orienttopath { get; set; }
        Transform[] IiTweenProperty.path_Transform { get; set; }
        Vector3[] IiTweenProperty.path_Vector3 { get; set; }
        float? IiTweenProperty.pitch { get; set; }
        Transform IiTweenProperty.position_Transform { get; set; }
        Vector3? IiTweenProperty.position_Vector3 { get; set; }
        float? IiTweenProperty.r { get; set; }
        Transform IiTweenProperty.rotation_Transform { get; set; }
        Vector3? IiTweenProperty.rotation_Vector3 { get; set; }
        /// <summary>
        /// for the initial scale
        /// </summary>
        public Transform scale_Transform { get; set; }
        /// <summary>
        /// for the initial scale
        /// </summary>
        public Vector3? scale_Vector3 { get; set; }
        Space IiTweenProperty.space { get; set; }
        /// <summary>
        /// can be used instead of time to allow animation based on speed
        /// </summary>
        public float? speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        float? IiTweenProperty.volume { get; set; }
        /// <summary>
        /// for the individual setting of the x axis
        /// </summary>
        public float? x { get; set; }
        /// <summary>
        /// for the individual setting of the y axis
        /// </summary>
        public float? y { get; set; }
        /// <summary>
        /// for the individual setting of the z axis
        /// </summary>
        public float? z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class ScaleTo : IiTweenProperty
    {
        iTweenBase.NamedValueColor IiTweenProperty.NamedColorValue { get; set; }
        float? IiTweenProperty.a { get; set; }
        float? IiTweenProperty.alpha { get; set; }
        float? IiTweenProperty.amount_float { get; set; }
        Vector3? IiTweenProperty.amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        AudioSource IiTweenProperty.audiosource { get; set; }
        string IiTweenProperty.axis { get; set; }
        float? IiTweenProperty.b { get; set; }
        Color? IiTweenProperty.color { get; set; }
        /// <summary>
        /// for the time in seconds the animation will wait before beginning
        /// </summary>
        public float? delay { get; set; }
        /// <summary>
        /// for the shape of the easing curve applied to the animation
        /// </summary>
        public iTweenBase.EaseType easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        float? IiTweenProperty.g { get; set; }
        /// <summary>
        /// setting this to true will allow the animation to continue independent of the current time which is helpful for animating menus after a game has been paused by setting Time.timeScale=0
        /// </summary>
        public bool ignoretimescale { get; set; }
        bool IiTweenProperty.includechildren { get; set; }
        bool IiTweenProperty.islocal { get; set; }
        float? IiTweenProperty.lookahead { get; set; }
        Transform IiTweenProperty.looktarget_Transform { get; set; }
        Vector3? IiTweenProperty.looktarget_Vector3 { get; set; }
        float? IiTweenProperty.looktime { get; set; }
        /// <summary>
        /// for the type of loop to apply once the animation has completed
        /// </summary>
        public iTweenBase.LoopType looptype { get; set; }
        bool IiTweenProperty.movetopath { get; set; }
        /// <summary>
        /// an individual name useful for stopping iTweens by name
        /// </summary>
        public string name { get; set; }
        bool IiTweenProperty.orienttopath { get; set; }
        Transform[] IiTweenProperty.path_Transform { get; set; }
        Vector3[] IiTweenProperty.path_Vector3 { get; set; }
        float? IiTweenProperty.pitch { get; set; }
        Transform IiTweenProperty.position_Transform { get; set; }
        Vector3? IiTweenProperty.position_Vector3 { get; set; }
        float? IiTweenProperty.r { get; set; }
        Transform IiTweenProperty.rotation_Transform { get; set; }
        Vector3? IiTweenProperty.rotation_Vector3 { get; set; }
        /// <summary>
        /// for the final scale
        /// </summary>
        public Transform scale_Transform { get; set; }
        /// <summary>
        /// for the final scale
        /// </summary>
        public Vector3? scale_Vector3 { get; set; }
        Space IiTweenProperty.space { get; set; }
        /// <summary>
        /// can be used instead of time to allow animation based on speed
        /// </summary>
        public float? speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        float? IiTweenProperty.volume { get; set; }
        /// <summary>
        /// for the individual setting of the x axis
        /// </summary>
        public float? x { get; set; }
        /// <summary>
        /// for the individual setting of the y axis
        /// </summary>
        public float? y { get; set; }
        /// <summary>
        /// for the individual setting of the z axis
        /// </summary>
        public float? z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class ScaleUpdate : IiTweenProperty
    {
        iTweenBase.NamedValueColor IiTweenProperty.NamedColorValue { get; set; }
        float? IiTweenProperty.a { get; set; }
        float? IiTweenProperty.alpha { get; set; }
        float? IiTweenProperty.amount_float { get; set; }
        Vector3? IiTweenProperty.amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        AudioSource IiTweenProperty.audiosource { get; set; }
        string IiTweenProperty.axis { get; set; }
        float? IiTweenProperty.b { get; set; }
        Color? IiTweenProperty.color { get; set; }
        float? IiTweenProperty.delay { get; set; }
        iTweenBase.EaseType IiTweenProperty.easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        float? IiTweenProperty.g { get; set; }
        bool IiTweenProperty.ignoretimescale { get; set; }
        bool IiTweenProperty.includechildren { get; set; }
        bool IiTweenProperty.islocal { get; set; }
        float? IiTweenProperty.lookahead { get; set; }
        Transform IiTweenProperty.looktarget_Transform { get; set; }
        Vector3? IiTweenProperty.looktarget_Vector3 { get; set; }
        float? IiTweenProperty.looktime { get; set; }
        iTweenBase.LoopType IiTweenProperty.looptype { get; set; }
        bool IiTweenProperty.movetopath { get; set; }
        string IiTweenProperty.name { get; set; }
        bool IiTweenProperty.orienttopath { get; set; }
        Transform[] IiTweenProperty.path_Transform { get; set; }
        Vector3[] IiTweenProperty.path_Vector3 { get; set; }
        float? IiTweenProperty.pitch { get; set; }
        Transform IiTweenProperty.position_Transform { get; set; }
        Vector3? IiTweenProperty.position_Vector3 { get; set; }
        float? IiTweenProperty.r { get; set; }
        Transform IiTweenProperty.rotation_Transform { get; set; }
        Vector3? IiTweenProperty.rotation_Vector3 { get; set; }
        /// <summary>
        /// for the final scale
        /// </summary>
        public Transform scale_Transform { get; set; }
        /// <summary>
        /// for the final scale
        /// </summary>
        public Vector3? scale_Vector3 { get; set; }
        Space IiTweenProperty.space { get; set; }
        float? IiTweenProperty.speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        float? IiTweenProperty.volume { get; set; }
        /// <summary>
        /// for the individual setting of the x axis
        /// </summary>
        public float? x { get; set; }
        /// <summary>
        /// for the individual setting of the y axis
        /// </summary>
        public float? y { get; set; }
        /// <summary>
        /// for the individual setting of the z axis
        /// </summary>
        public float? z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class ShakePosition : IiTweenProperty
    {
        iTweenBase.NamedValueColor IiTweenProperty.NamedColorValue { get; set; }
        float? IiTweenProperty.a { get; set; }
        float? IiTweenProperty.alpha { get; set; }
        float? IiTweenProperty.amount_float { get; set; }
        /// <summary>
        /// for the magnitude of shake
        /// </summary>
        public Vector3? amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        AudioSource IiTweenProperty.audiosource { get; set; }
        /// <summary>
        /// restricts rotation to the supplied axis only
        /// </summary>
        public string axis { get; set; }
        float? IiTweenProperty.b { get; set; }
        Color? IiTweenProperty.color { get; set; }
        /// <summary>
        /// for the time in seconds the animation will wait before beginning
        /// </summary>
        public float? delay { get; set; }
        iTweenBase.EaseType IiTweenProperty.easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        float? IiTweenProperty.g { get; set; }
        /// <summary>
        /// setting this to true will allow the animation to continue independent of the current time which is helpful for animating menus after a game has been paused by setting Time.timeScale=0
        /// </summary>
        public bool ignoretimescale { get; set; }
        bool IiTweenProperty.includechildren { get; set; }
        /// <summary>
        /// for whether to animate in world space or relative to the parent. False by default.
        /// </summary>
        public bool islocal { get; set; }
        float? IiTweenProperty.lookahead { get; set; }
        /// <summary>
        /// for a target the GameObject will look at
        /// </summary>
        public Transform looktarget_Transform { get; set; }
        /// <summary>
        /// for a target the GameObject will look at
        /// </summary>
        public Vector3? looktarget_Vector3 { get; set; }
        /// <summary>
        /// for the time in seconds the object will take to look at either the "looktarget" or "orienttopath"
        /// </summary>
        public float? looktime { get; set; }
        /// <summary>
        /// for the type of loop to apply once the animation has completed (only "loop" is allowed with shakes)
        /// </summary>
        public iTweenBase.LoopType looptype { get; set; }
        bool IiTweenProperty.movetopath { get; set; }
        /// <summary>
        /// an individual name useful for stopping iTweens by name
        /// </summary>
        public string name { get; set; }
        /// <summary>
        /// for whether or not the GameObject will orient to its direction of travel.  False by default
        /// </summary>
        public bool orienttopath { get; set; }
        Transform[] IiTweenProperty.path_Transform { get; set; }
        Vector3[] IiTweenProperty.path_Vector3 { get; set; }
        float? IiTweenProperty.pitch { get; set; }
        Transform IiTweenProperty.position_Transform { get; set; }
        Vector3? IiTweenProperty.position_Vector3 { get; set; }
        float? IiTweenProperty.r { get; set; }
        Transform IiTweenProperty.rotation_Transform { get; set; }
        Vector3? IiTweenProperty.rotation_Vector3 { get; set; }
        Transform IiTweenProperty.scale_Transform { get; set; }
        Vector3? IiTweenProperty.scale_Vector3 { get; set; }
        Space IiTweenProperty.space { get; set; }
        float? IiTweenProperty.speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        float? IiTweenProperty.volume { get; set; }
        /// <summary>
        /// for the individual setting of the x magnitude
        /// </summary>
        public float? x { get; set; }
        /// <summary>
        /// for the individual setting of the y magnitude
        /// </summary>
        public float? y { get; set; }
        /// <summary>
        /// for the individual setting of the z magnitude
        /// </summary>
        public float? z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class ShakeRotation : IiTweenProperty
    {
        iTweenBase.NamedValueColor IiTweenProperty.NamedColorValue { get; set; }
        float? IiTweenProperty.a { get; set; }
        float? IiTweenProperty.alpha { get; set; }
        float? IiTweenProperty.amount_float { get; set; }
        /// <summary>
        /// for the magnitude of shake
        /// </summary>
        public Vector3? amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        AudioSource IiTweenProperty.audiosource { get; set; }
        string IiTweenProperty.axis { get; set; }
        float? IiTweenProperty.b { get; set; }
        Color? IiTweenProperty.color { get; set; }
        /// <summary>
        /// for the time in seconds the animation will wait before beginning
        /// </summary>
        public float? delay { get; set; }
        iTweenBase.EaseType IiTweenProperty.easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        float? IiTweenProperty.g { get; set; }
        /// <summary>
        /// setting this to true will allow the animation to continue independent of the current time which is helpful for animating menus after a game has been paused by setting Time.timeScale=0
        /// </summary>
        public bool ignoretimescale { get; set; }
        bool IiTweenProperty.includechildren { get; set; }
        bool IiTweenProperty.islocal { get; set; }
        float? IiTweenProperty.lookahead { get; set; }
        Transform IiTweenProperty.looktarget_Transform { get; set; }
        Vector3? IiTweenProperty.looktarget_Vector3 { get; set; }
        float? IiTweenProperty.looktime { get; set; }
        /// <summary>
        /// for the type of loop to apply once the animation has completed (only "loop" is allowed with shakes)
        /// </summary>
        public iTweenBase.LoopType looptype { get; set; }
        bool IiTweenProperty.movetopath { get; set; }
        /// <summary>
        /// an individual name useful for stopping iTweens by name
        /// </summary>
        public string name { get; set; }
        bool IiTweenProperty.orienttopath { get; set; }
        Transform[] IiTweenProperty.path_Transform { get; set; }
        Vector3[] IiTweenProperty.path_Vector3 { get; set; }
        float? IiTweenProperty.pitch { get; set; }
        Transform IiTweenProperty.position_Transform { get; set; }
        Vector3? IiTweenProperty.position_Vector3 { get; set; }
        float? IiTweenProperty.r { get; set; }
        Transform IiTweenProperty.rotation_Transform { get; set; }
        Vector3? IiTweenProperty.rotation_Vector3 { get; set; }
        Transform IiTweenProperty.scale_Transform { get; set; }
        Vector3? IiTweenProperty.scale_Vector3 { get; set; }
        /// <summary>
        /// for applying the transformation in either the world coordinate or local coordinate system. Defaults to local space.
        /// </summary>
        public Space space { get; set; }
        float? IiTweenProperty.speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        float? IiTweenProperty.volume { get; set; }
        /// <summary>
        /// for the individual setting of the x magnitude
        /// </summary>
        public float? x { get; set; }
        /// <summary>
        /// for the individual setting of the y magnitude
        /// </summary>
        public float? y { get; set; }
        /// <summary>
        /// for the individual setting of the z magnitude
        /// </summary>
        public float? z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class ShakeScale : IiTweenProperty
    {
        iTweenBase.NamedValueColor IiTweenProperty.NamedColorValue { get; set; }
        float? IiTweenProperty.a { get; set; }
        float? IiTweenProperty.alpha { get; set; }
        float? IiTweenProperty.amount_float { get; set; }
        /// <summary>
        /// for the magnitude of shake
        /// </summary>
        public Vector3? amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        AudioSource IiTweenProperty.audiosource { get; set; }
        string IiTweenProperty.axis { get; set; }
        float? IiTweenProperty.b { get; set; }
        Color? IiTweenProperty.color { get; set; }
        /// <summary>
        /// for the time in seconds the animation will wait before beginning
        /// </summary>
        public float? delay { get; set; }
        iTweenBase.EaseType IiTweenProperty.easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        float? IiTweenProperty.g { get; set; }
        /// <summary>
        /// setting this to true will allow the animation to continue independent of the current time which is helpful for animating menus after a game has been paused by setting Time.timeScale=0
        /// </summary>
        public bool ignoretimescale { get; set; }
        bool IiTweenProperty.includechildren { get; set; }
        bool IiTweenProperty.islocal { get; set; }
        float? IiTweenProperty.lookahead { get; set; }
        Transform IiTweenProperty.looktarget_Transform { get; set; }
        Vector3? IiTweenProperty.looktarget_Vector3 { get; set; }
        float? IiTweenProperty.looktime { get; set; }
        /// <summary>
        /// for the type of loop to apply once the animation has completed (only "loop" is allowed with shakes)
        /// </summary>
        public iTweenBase.LoopType looptype { get; set; }
        bool IiTweenProperty.movetopath { get; set; }
        /// <summary>
        /// an individual name useful for stopping iTweens by name
        /// </summary>
        public string name { get; set; }
        bool IiTweenProperty.orienttopath { get; set; }
        Transform[] IiTweenProperty.path_Transform { get; set; }
        Vector3[] IiTweenProperty.path_Vector3 { get; set; }
        float? IiTweenProperty.pitch { get; set; }
        Transform IiTweenProperty.position_Transform { get; set; }
        Vector3? IiTweenProperty.position_Vector3 { get; set; }
        float? IiTweenProperty.r { get; set; }
        Transform IiTweenProperty.rotation_Transform { get; set; }
        Vector3? IiTweenProperty.rotation_Vector3 { get; set; }
        Transform IiTweenProperty.scale_Transform { get; set; }
        Vector3? IiTweenProperty.scale_Vector3 { get; set; }
        Space IiTweenProperty.space { get; set; }
        float? IiTweenProperty.speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        float? IiTweenProperty.volume { get; set; }
        /// <summary>
        /// for the individual setting of the x magnitude
        /// </summary>
        public float? x { get; set; }
        /// <summary>
        /// for the individual setting of the y magnitude
        /// </summary>
        public float? y { get; set; }
        /// <summary>
        /// for the individual setting of the z magnitude
        /// </summary>
        public float? z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class Stab : IiTweenProperty
    {
        iTweenBase.NamedValueColor IiTweenProperty.NamedColorValue { get; set; }
        float? IiTweenProperty.a { get; set; }
        float? IiTweenProperty.alpha { get; set; }
        float? IiTweenProperty.amount_float { get; set; }
        Vector3? IiTweenProperty.amount_Vector3 { get; set; }
        /// <summary>
        /// for a reference to the AudioClip to be played.
        /// </summary>
        public AudioClip audioclip { get; set; }
        /// <summary>
        /// for which AudioSource to use
        /// </summary>
        public AudioSource audiosource { get; set; }
        string IiTweenProperty.axis { get; set; }
        float? IiTweenProperty.b { get; set; }
        Color? IiTweenProperty.color { get; set; }
        /// <summary>
        /// for the time in seconds the action will wait before beginning
        /// </summary>
        public float? delay { get; set; }
        iTweenBase.EaseType IiTweenProperty.easetype { get; set; }
        Color? IiTweenProperty.from_Color { get; set; }
        Rect? IiTweenProperty.from_Rect { get; set; }
        Vector2? IiTweenProperty.from_Vector2 { get; set; }
        Vector3? IiTweenProperty.from_Vector3 { get; set; }
        float? IiTweenProperty.from_float { get; set; }
        float? IiTweenProperty.g { get; set; }
        bool IiTweenProperty.ignoretimescale { get; set; }
        bool IiTweenProperty.includechildren { get; set; }
        bool IiTweenProperty.islocal { get; set; }
        float? IiTweenProperty.lookahead { get; set; }
        Transform IiTweenProperty.looktarget_Transform { get; set; }
        Vector3? IiTweenProperty.looktarget_Vector3 { get; set; }
        float? IiTweenProperty.looktime { get; set; }
        iTweenBase.LoopType IiTweenProperty.looptype { get; set; }
        bool IiTweenProperty.movetopath { get; set; }
        string IiTweenProperty.name { get; set; }
        bool IiTweenProperty.orienttopath { get; set; }
        Transform[] IiTweenProperty.path_Transform { get; set; }
        Vector3[] IiTweenProperty.path_Vector3 { get; set; }
        /// <summary>
        /// for the target pitch
        /// </summary>
        public float? pitch { get; set; }
        Transform IiTweenProperty.position_Transform { get; set; }
        Vector3? IiTweenProperty.position_Vector3 { get; set; }
        float? IiTweenProperty.r { get; set; }
        Transform IiTweenProperty.rotation_Transform { get; set; }
        Vector3? IiTweenProperty.rotation_Vector3 { get; set; }
        Transform IiTweenProperty.scale_Transform { get; set; }
        Vector3? IiTweenProperty.scale_Vector3 { get; set; }
        Space IiTweenProperty.space { get; set; }
        float? IiTweenProperty.speed { get; set; }
        float? IiTweenProperty.time { get; set; }
        Color? IiTweenProperty.to_Color { get; set; }
        Rect? IiTweenProperty.to_Rect { get; set; }
        Vector2? IiTweenProperty.to_Vector2 { get; set; }
        Vector3? IiTweenProperty.to_Vector3 { get; set; }
        float? IiTweenProperty.to_float { get; set; }
        /// <summary>
        /// for the target level of volume
        /// </summary>
        public float? volume { get; set; }
        float? IiTweenProperty.x { get; set; }
        float? IiTweenProperty.y { get; set; }
        float? IiTweenProperty.z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }

    public class ValueTo : IiTweenProperty
    {
        iTweenBase.NamedValueColor IiTweenProperty.NamedColorValue { get; set; }
        float? IiTweenProperty.a { get; set; }
        float? IiTweenProperty.alpha { get; set; }
        float? IiTweenProperty.amount_float { get; set; }
        Vector3? IiTweenProperty.amount_Vector3 { get; set; }
        AudioClip IiTweenProperty.audioclip { get; set; }
        AudioSource IiTweenProperty.audiosource { get; set; }
        string IiTweenProperty.axis { get; set; }
        float? IiTweenProperty.b { get; set; }
        Color? IiTweenProperty.color { get; set; }
        /// <summary>
        /// for the time in seconds the action will wait before beginning
        /// </summary>
        public float? delay { get; set; }
        /// <summary>
        /// for the shape of the easing curve applied to the animation
        /// </summary>
        public iTweenBase.EaseType easetype { get; set; }
        /// <summary>
        /// for the starting value.
        /// </summary>
        public Color? from_Color { get; set; }
        /// <summary>
        /// for the starting value.
        /// </summary>
        public Rect? from_Rect { get; set; }
        /// <summary>
        /// for the starting value.
        /// </summary>
        public Vector2? from_Vector2 { get; set; }
        /// <summary>
        /// for the starting value.
        /// </summary>
        public Vector3? from_Vector3 { get; set; }
        /// <summary>
        /// for the starting value.
        /// </summary>
        public float? from_float { get; set; }
        float? IiTweenProperty.g { get; set; }
        /// <summary>
        /// setting this to true will allow the animation to continue independent of the current time which is helpful for animating menus after a game has been paused by setting Time.timeScale=0
        /// </summary>
        public bool ignoretimescale { get; set; }
        bool IiTweenProperty.includechildren { get; set; }
        bool IiTweenProperty.islocal { get; set; }
        float? IiTweenProperty.lookahead { get; set; }
        Transform IiTweenProperty.looktarget_Transform { get; set; }
        Vector3? IiTweenProperty.looktarget_Vector3 { get; set; }
        float? IiTweenProperty.looktime { get; set; }
        public iTweenBase.LoopType looptype { get; set; }
        bool IiTweenProperty.movetopath { get; set; }
        /// <summary>
        /// an individual name useful for stopping iTweens by name
        /// </summary>
        public string name { get; set; }
        bool IiTweenProperty.orienttopath { get; set; }
        Transform[] IiTweenProperty.path_Transform { get; set; }
        Vector3[] IiTweenProperty.path_Vector3 { get; set; }
        float? IiTweenProperty.pitch { get; set; }
        Transform IiTweenProperty.position_Transform { get; set; }
        Vector3? IiTweenProperty.position_Vector3 { get; set; }
        float? IiTweenProperty.r { get; set; }
        Transform IiTweenProperty.rotation_Transform { get; set; }
        Vector3? IiTweenProperty.rotation_Vector3 { get; set; }
        Transform IiTweenProperty.scale_Transform { get; set; }
        Vector3? IiTweenProperty.scale_Vector3 { get; set; }
        Space IiTweenProperty.space { get; set; }
        /// <summary>
        /// can be used instead of time to allow animation based on speed (only works with Vector2, Vector3, and Floats)
        /// </summary>
        public float? speed { get; set; }
        /// <summary>
        /// for the time in seconds the animation will take to complete
        /// </summary>
        public float? time { get; set; }
        /// <summary>
        /// for the ending value.
        /// </summary>
        public Color? to_Color { get; set; }
        /// <summary>
        /// for the ending value.
        /// </summary>
        public Rect? to_Rect { get; set; }
        /// <summary>
        /// for the ending value.
        /// </summary>
        public Vector2? to_Vector2 { get; set; }
        /// <summary>
        /// for the ending value.
        /// </summary>
        public Vector3? to_Vector3 { get; set; }
        /// <summary>
        /// for the ending value.
        /// </summary>
        public float? to_float { get; set; }
        float? IiTweenProperty.volume { get; set; }
        float? IiTweenProperty.x { get; set; }
        float? IiTweenProperty.y { get; set; }
        float? IiTweenProperty.z { get; set; }
        public Hashtable ToHastable()
        {
            return iTweenProperty.GetProperties(this);
        }
    }
}
